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
general updates and bug fixes
tilakpatel22886a6ccd1753
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/corporateFinance/merger_models/merger_model.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/corporateFinance/merger_models/merger_model.pyindex 18fb33165..922b14251 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/corporateFinance/merger_models/merger_model.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/corporateFinance/merger_models/merger_model.py@@ -285,14 +285,21 @@ def main():target = json.loads(sys.argv[3])year = int(sys.argv[4])+ # Derive purchase price from available data; fall back to 2x target EBITDA or 1x revenue+ target_ev = target.get('enterprise_value', target.get('market_cap', 0))+ if not target_ev:+ target_ebitda = target.get('ebitda', 0)+ target_revenue = target.get('revenue', 0)+ target_ev = target_ebitda * 8 if target_ebitda else target_revenue * 1.5+deal_terms = {- 'purchase_price': target.get('enterprise_value', target.get('market_cap', 0)),- 'cash_consideration': target.get('enterprise_value', 0) * 0.5,- 'stock_consideration': target.get('enterprise_value', 0) * 0.5,+ 'purchase_price': target_ev,+ 'cash_consideration': target_ev * 0.5,+ 'stock_consideration': target_ev * 0.5,'acquirer_stock_price': acquirer.get('stock_price', 100),- 'synergies': 0,- 'integration_costs': 0,- 'tax_rate': 0.21,+ 'synergies': acquirer.get('synergies', 0),+ 'integration_costs': acquirer.get('integration_costs', 0),+ 'tax_rate': acquirer.get('tax_rate', 0.21),}model = MergerModel(acquirer, target, deal_terms)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quantstats_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quantstats_analytics.pyindex a6c745384..0791fb7e5 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quantstats_analytics.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quantstats_analytics.py@@ -467,13 +467,20 @@ def compute_drawdowns(portfolio_returns: pd.Series) -> dict:try:dd_details = qs.stats.drawdown_details(dd_series)if dd_details is not None and len(dd_details) > 0:+ # Flatten MultiIndex columns (e.g. ('AAPL', 'start') -> 'start')+ if isinstance(dd_details.columns, pd.MultiIndex):+ dd_details.columns = dd_details.columns.get_level_values(-1)periods = []for _, row in dd_details.head(10).iterrows():period = {}for col in dd_details.columns:val = row[col]- if isinstance(val, pd.Timestamp):+ if val is pd.NaT or (isinstance(val, float) and np.isnan(val)):+ period[col] = None+ elif isinstance(val, pd.Timestamp):period[col] = val.strftime("%Y-%m-%d")+ elif isinstance(val, str):+ period[col] = valelif isinstance(val, (int, np.integer)):period[col] = int(val)else:diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/american_primacy_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/american_primacy_agent.pydeleted file mode 100644index b4392f554..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/american_primacy_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-EURASIAN BALKANS AGENT - Brzezinski's Framework (FinAgent Core)-Based on "The Grand Chessboard" by Zbigniew Brzezinski--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--BRZEZINSKI THESIS: Central Asia/Caucasus as pivotal geopolitical space-where great powers compete for influence and resources.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class EurasianBalkansAgent:- """- Eurasian Balkans Agent using FinAgent Core-- Analyzes Central Asia through:- - Pivotal geopolitical space concept- - Great power competition (Russia, China, West)- - Energy resources and pipeline politics- - Ethnic/religious fault lines- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("grand_chessboard_eurasian")-- if not self.config:- raise ValueError("Eurasian balkans agent config not found in JSON")-- # Brzezinski's framework- self.strategic_framework = {- "pivotal_space": {- "concept": "Region where control determines global power",- "states": "Kazakhstan, Uzbekistan, Turkmenistan, Azerbaijan, Georgia",- "importance": "Buffer between Russia, China, Middle East",- "current_dynamics": "SCO, CSTO, Belt and Road competition"- },- "energy_politics": {- "resources": "Oil, natural gas reserves",- "pipelines": "Competing routes (Russia vs West vs China)",- "strategic_value": "Energy independence from Russia",- "current_dynamics": "Diversification efforts, Chinese investment"- },- "great_power_competition": {- "russia": "Historical sphere of influence, reassertion",- "china": "Economic penetration via BRI, SCO",- "west": "Democracy promotion, energy access",- "current_dynamics": "Russia-China alignment vs West"- },- "instability_factors": {- "ethnic_tensions": "Multi-ethnic states, Russian minorities",- "islamic_radicalism": "Taliban, ISIS spillover",- "authoritarianism": "Weak institutions, strongmen",- "current_dynamics": "Afghanistan collapse impact"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Brzezinski's Grand Chessboard lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-Grand Chessboard Framework (Brzezinski):-{self._format_framework()}--Query: {query}--Analyze through Eurasian Balkans strategic framework.-"""- return context-- def _format_framework(self) -> str:- """Format strategic framework for context"""- formatted = []- for name, data in self.strategic_framework.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Concept: {data.get('concept', 'N/A')}")- formatted.append(f" Current: {data['current_dynamics']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Eurasian Balkans Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = EurasianBalkansAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/eurasian_balkans_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/eurasian_balkans_agent.pydeleted file mode 100644index b4392f554..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/eurasian_balkans_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-EURASIAN BALKANS AGENT - Brzezinski's Framework (FinAgent Core)-Based on "The Grand Chessboard" by Zbigniew Brzezinski--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--BRZEZINSKI THESIS: Central Asia/Caucasus as pivotal geopolitical space-where great powers compete for influence and resources.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class EurasianBalkansAgent:- """- Eurasian Balkans Agent using FinAgent Core-- Analyzes Central Asia through:- - Pivotal geopolitical space concept- - Great power competition (Russia, China, West)- - Energy resources and pipeline politics- - Ethnic/religious fault lines- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("grand_chessboard_eurasian")-- if not self.config:- raise ValueError("Eurasian balkans agent config not found in JSON")-- # Brzezinski's framework- self.strategic_framework = {- "pivotal_space": {- "concept": "Region where control determines global power",- "states": "Kazakhstan, Uzbekistan, Turkmenistan, Azerbaijan, Georgia",- "importance": "Buffer between Russia, China, Middle East",- "current_dynamics": "SCO, CSTO, Belt and Road competition"- },- "energy_politics": {- "resources": "Oil, natural gas reserves",- "pipelines": "Competing routes (Russia vs West vs China)",- "strategic_value": "Energy independence from Russia",- "current_dynamics": "Diversification efforts, Chinese investment"- },- "great_power_competition": {- "russia": "Historical sphere of influence, reassertion",- "china": "Economic penetration via BRI, SCO",- "west": "Democracy promotion, energy access",- "current_dynamics": "Russia-China alignment vs West"- },- "instability_factors": {- "ethnic_tensions": "Multi-ethnic states, Russian minorities",- "islamic_radicalism": "Taliban, ISIS spillover",- "authoritarianism": "Weak institutions, strongmen",- "current_dynamics": "Afghanistan collapse impact"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Brzezinski's Grand Chessboard lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-Grand Chessboard Framework (Brzezinski):-{self._format_framework()}--Query: {query}--Analyze through Eurasian Balkans strategic framework.-"""- return context-- def _format_framework(self) -> str:- """Format strategic framework for context"""- formatted = []- for name, data in self.strategic_framework.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Concept: {data.get('concept', 'N/A')}")- formatted.append(f" Current: {data['current_dynamics']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Eurasian Balkans Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = EurasianBalkansAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/heartland_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/heartland_agent.pydeleted file mode 100644index b4392f554..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/heartland_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-EURASIAN BALKANS AGENT - Brzezinski's Framework (FinAgent Core)-Based on "The Grand Chessboard" by Zbigniew Brzezinski--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--BRZEZINSKI THESIS: Central Asia/Caucasus as pivotal geopolitical space-where great powers compete for influence and resources.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class EurasianBalkansAgent:- """- Eurasian Balkans Agent using FinAgent Core-- Analyzes Central Asia through:- - Pivotal geopolitical space concept- - Great power competition (Russia, China, West)- - Energy resources and pipeline politics- - Ethnic/religious fault lines- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("grand_chessboard_eurasian")-- if not self.config:- raise ValueError("Eurasian balkans agent config not found in JSON")-- # Brzezinski's framework- self.strategic_framework = {- "pivotal_space": {- "concept": "Region where control determines global power",- "states": "Kazakhstan, Uzbekistan, Turkmenistan, Azerbaijan, Georgia",- "importance": "Buffer between Russia, China, Middle East",- "current_dynamics": "SCO, CSTO, Belt and Road competition"- },- "energy_politics": {- "resources": "Oil, natural gas reserves",- "pipelines": "Competing routes (Russia vs West vs China)",- "strategic_value": "Energy independence from Russia",- "current_dynamics": "Diversification efforts, Chinese investment"- },- "great_power_competition": {- "russia": "Historical sphere of influence, reassertion",- "china": "Economic penetration via BRI, SCO",- "west": "Democracy promotion, energy access",- "current_dynamics": "Russia-China alignment vs West"- },- "instability_factors": {- "ethnic_tensions": "Multi-ethnic states, Russian minorities",- "islamic_radicalism": "Taliban, ISIS spillover",- "authoritarianism": "Weak institutions, strongmen",- "current_dynamics": "Afghanistan collapse impact"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Brzezinski's Grand Chessboard lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-Grand Chessboard Framework (Brzezinski):-{self._format_framework()}--Query: {query}--Analyze through Eurasian Balkans strategic framework.-"""- return context-- def _format_framework(self) -> str:- """Format strategic framework for context"""- formatted = []- for name, data in self.strategic_framework.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Concept: {data.get('concept', 'N/A')}")- formatted.append(f" Current: {data['current_dynamics']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Eurasian Balkans Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = EurasianBalkansAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/pivots_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/pivots_agent.pydeleted file mode 100644index b4392f554..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/pivots_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-EURASIAN BALKANS AGENT - Brzezinski's Framework (FinAgent Core)-Based on "The Grand Chessboard" by Zbigniew Brzezinski--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--BRZEZINSKI THESIS: Central Asia/Caucasus as pivotal geopolitical space-where great powers compete for influence and resources.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class EurasianBalkansAgent:- """- Eurasian Balkans Agent using FinAgent Core-- Analyzes Central Asia through:- - Pivotal geopolitical space concept- - Great power competition (Russia, China, West)- - Energy resources and pipeline politics- - Ethnic/religious fault lines- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("grand_chessboard_eurasian")-- if not self.config:- raise ValueError("Eurasian balkans agent config not found in JSON")-- # Brzezinski's framework- self.strategic_framework = {- "pivotal_space": {- "concept": "Region where control determines global power",- "states": "Kazakhstan, Uzbekistan, Turkmenistan, Azerbaijan, Georgia",- "importance": "Buffer between Russia, China, Middle East",- "current_dynamics": "SCO, CSTO, Belt and Road competition"- },- "energy_politics": {- "resources": "Oil, natural gas reserves",- "pipelines": "Competing routes (Russia vs West vs China)",- "strategic_value": "Energy independence from Russia",- "current_dynamics": "Diversification efforts, Chinese investment"- },- "great_power_competition": {- "russia": "Historical sphere of influence, reassertion",- "china": "Economic penetration via BRI, SCO",- "west": "Democracy promotion, energy access",- "current_dynamics": "Russia-China alignment vs West"- },- "instability_factors": {- "ethnic_tensions": "Multi-ethnic states, Russian minorities",- "islamic_radicalism": "Taliban, ISIS spillover",- "authoritarianism": "Weak institutions, strongmen",- "current_dynamics": "Afghanistan collapse impact"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Brzezinski's Grand Chessboard lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-Grand Chessboard Framework (Brzezinski):-{self._format_framework()}--Query: {query}--Analyze through Eurasian Balkans strategic framework.-"""- return context-- def _format_framework(self) -> str:- """Format strategic framework for context"""- formatted = []- for name, data in self.strategic_framework.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Concept: {data.get('concept', 'N/A')}")- formatted.append(f" Current: {data['current_dynamics']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Eurasian Balkans Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = EurasianBalkansAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/players_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/players_agent.pydeleted file mode 100644index b4392f554..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/players_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-EURASIAN BALKANS AGENT - Brzezinski's Framework (FinAgent Core)-Based on "The Grand Chessboard" by Zbigniew Brzezinski--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--BRZEZINSKI THESIS: Central Asia/Caucasus as pivotal geopolitical space-where great powers compete for influence and resources.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class EurasianBalkansAgent:- """- Eurasian Balkans Agent using FinAgent Core-- Analyzes Central Asia through:- - Pivotal geopolitical space concept- - Great power competition (Russia, China, West)- - Energy resources and pipeline politics- - Ethnic/religious fault lines- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("grand_chessboard_eurasian")-- if not self.config:- raise ValueError("Eurasian balkans agent config not found in JSON")-- # Brzezinski's framework- self.strategic_framework = {- "pivotal_space": {- "concept": "Region where control determines global power",- "states": "Kazakhstan, Uzbekistan, Turkmenistan, Azerbaijan, Georgia",- "importance": "Buffer between Russia, China, Middle East",- "current_dynamics": "SCO, CSTO, Belt and Road competition"- },- "energy_politics": {- "resources": "Oil, natural gas reserves",- "pipelines": "Competing routes (Russia vs West vs China)",- "strategic_value": "Energy independence from Russia",- "current_dynamics": "Diversification efforts, Chinese investment"- },- "great_power_competition": {- "russia": "Historical sphere of influence, reassertion",- "china": "Economic penetration via BRI, SCO",- "west": "Democracy promotion, energy access",- "current_dynamics": "Russia-China alignment vs West"- },- "instability_factors": {- "ethnic_tensions": "Multi-ethnic states, Russian minorities",- "islamic_radicalism": "Taliban, ISIS spillover",- "authoritarianism": "Weak institutions, strongmen",- "current_dynamics": "Afghanistan collapse impact"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Brzezinski's Grand Chessboard lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-Grand Chessboard Framework (Brzezinski):-{self._format_framework()}--Query: {query}--Analyze through Eurasian Balkans strategic framework.-"""- return context-- def _format_framework(self) -> str:- """Format strategic framework for context"""- formatted = []- for name, data in self.strategic_framework.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Concept: {data.get('concept', 'N/A')}")- formatted.append(f" Current: {data['current_dynamics']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Eurasian Balkans Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = EurasianBalkansAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/africa_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/africa_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/africa_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/arctic_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/arctic_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/arctic_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/china_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/china_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/china_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/europe_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/europe_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/europe_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/india_pakistan_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/india_pakistan_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/india_pakistan_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/japan_korea_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/japan_korea_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/japan_korea_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/latin_america_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/latin_america_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/latin_america_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/middle_east_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/middle_east_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/middle_east_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/russia_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/russia_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/russia_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/usa_geography_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/usa_geography_agent.pydeleted file mode 100644index 0c6459037..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/usa_geography_agent.py+++ /dev/null@@ -1,114 +0,0 @@-"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)-Based on "Prisoners of Geography" Chapter 1--This agent now uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--MARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain's-vulnerability forces expansion, warm-water port obsession drives foreign policy,-and vast territory creates perpetual security challenges.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class RussiaGeographyAgent:- """- Russia Geography Agent using FinAgent Core-- Geographic constraints analyzed:- - North European Plain vulnerability → buffer state creation- - Warm-water port obsession → Crimea, Syria policies- - Vast territory → logistical challenges- - Climate limitations → agricultural constraints- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("prisoners_geography_russia")-- if not self.config:- raise ValueError("Russia geography agent config not found in JSON")-- # Geographic constraints from Marshall's framework- self.geographic_prisons = {- "north_european_plain": {- "constraint": "Flat invasion route from Europe",- "historical_vulnerability": "Napoleon, Hitler, NATO expansion",- "strategic_imperative": "Buffer state creation",- "current_implications": "Ukraine, Belarus, Baltic states"- },- "warm_water_ports": {- "constraint": "Most ports frozen year-round",- "historical_obsession": "Black Sea, Baltic, Pacific access",- "strategic_imperative": "Year-round naval presence",- "current_implications": "Crimea annexation, Syria presence"- },- "vast_territory": {- "constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs",- "strategic_imperative": "Control of transport corridors",- "current_implications": "Rail networks, pipeline control"- },- "climate_agriculture": {- "constraint": "Only 12% arable land, permafrost",- "food_security_issue": "Limited agricultural heartland",- "strategic_imperative": "Ukraine grain belt control",- "current_implications": "Southern expansion"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Marshall's geographic determinism lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Geographic Constraints for Russia:-{self._format_constraints()}--Query: {query}--Analyze this through Marshall's framework, connecting to geographic determinism.-"""- return context-- def _format_constraints(self) -> str:- """Format geographic constraints for context"""- formatted = []- for name, data in self.geographic_prisons.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Constraint: {data['constraint']}")- formatted.append(f" Imperative: {data['strategic_imperative']}")- formatted.append(f" Current: {data['current_implications']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Russia Geography Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = RussiaGeographyAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/american_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/american_order_agent.pydeleted file mode 100644index eb36930d1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/american_order_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Kissinger's Framework (FinAgent Core)-Based on "World Order" by Henry Kissinger--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--KISSINGER THESIS: American world order based on liberal internationalism,-democratic values, and post-WWII institutional framework.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class AmericanOrderAgent:- """- American World Order Agent using FinAgent Core-- Analyzes events through:- - Liberal internationalist principles- - Democratic value promotion- - American exceptionalism- - Post-WWII institutions (UN, NATO, IMF, World Bank)- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("world_order_american")-- if not self.config:- raise ValueError("American world order agent config not found in JSON")-- # American order principles- self.order_principles = {- "liberal_internationalism": {- "principle": "Rules-based international order",- "institutions": "UN, WTO, IMF, World Bank",- "values": "Democracy, human rights, free markets",- "current_challenges": "Rising authoritarianism, trade wars"- },- "democratic_promotion": {- "principle": "Democratic peace theory",- "strategy": "Democracy promotion abroad",- "tension": "Idealism vs realpolitik",- "current_challenges": "Failed interventions, illiberal democracies"- },- "american_exceptionalism": {- "principle": "Unique American role in world affairs",- "manifest_destiny": "Leadership of free world",- "burden": "Global policeman role",- "current_challenges": "War fatigue, isolationism"- },- "institutional_framework": {- "principle": "Multilateral institutions",- "nato": "Collective security in Europe",- "alliances": "Hub-and-spoke in Asia",- "current_challenges": "Burden-sharing, relevance"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Kissinger's American world order lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-American World Order Principles (Kissinger):-{self._format_principles()}--Query: {query}--Analyze through American world order framework.-"""- return context-- def _format_principles(self) -> str:- """Format order principles for context"""- formatted = []- for name, data in self.order_principles.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Principle: {data['principle']}")- formatted.append(f" Current: {data.get('current_challenges', 'N/A')}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="American World Order Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = AmericanOrderAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/chinese_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/chinese_order_agent.pydeleted file mode 100644index eb36930d1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/chinese_order_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Kissinger's Framework (FinAgent Core)-Based on "World Order" by Henry Kissinger--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--KISSINGER THESIS: American world order based on liberal internationalism,-democratic values, and post-WWII institutional framework.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class AmericanOrderAgent:- """- American World Order Agent using FinAgent Core-- Analyzes events through:- - Liberal internationalist principles- - Democratic value promotion- - American exceptionalism- - Post-WWII institutions (UN, NATO, IMF, World Bank)- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("world_order_american")-- if not self.config:- raise ValueError("American world order agent config not found in JSON")-- # American order principles- self.order_principles = {- "liberal_internationalism": {- "principle": "Rules-based international order",- "institutions": "UN, WTO, IMF, World Bank",- "values": "Democracy, human rights, free markets",- "current_challenges": "Rising authoritarianism, trade wars"- },- "democratic_promotion": {- "principle": "Democratic peace theory",- "strategy": "Democracy promotion abroad",- "tension": "Idealism vs realpolitik",- "current_challenges": "Failed interventions, illiberal democracies"- },- "american_exceptionalism": {- "principle": "Unique American role in world affairs",- "manifest_destiny": "Leadership of free world",- "burden": "Global policeman role",- "current_challenges": "War fatigue, isolationism"- },- "institutional_framework": {- "principle": "Multilateral institutions",- "nato": "Collective security in Europe",- "alliances": "Hub-and-spoke in Asia",- "current_challenges": "Burden-sharing, relevance"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Kissinger's American world order lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-American World Order Principles (Kissinger):-{self._format_principles()}--Query: {query}--Analyze through American world order framework.-"""- return context-- def _format_principles(self) -> str:- """Format order principles for context"""- formatted = []- for name, data in self.order_principles.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Principle: {data['principle']}")- formatted.append(f" Current: {data.get('current_challenges', 'N/A')}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="American World Order Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = AmericanOrderAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/european_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/european_order_agent.pydeleted file mode 100644index eb36930d1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/european_order_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Kissinger's Framework (FinAgent Core)-Based on "World Order" by Henry Kissinger--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--KISSINGER THESIS: American world order based on liberal internationalism,-democratic values, and post-WWII institutional framework.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class AmericanOrderAgent:- """- American World Order Agent using FinAgent Core-- Analyzes events through:- - Liberal internationalist principles- - Democratic value promotion- - American exceptionalism- - Post-WWII institutions (UN, NATO, IMF, World Bank)- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("world_order_american")-- if not self.config:- raise ValueError("American world order agent config not found in JSON")-- # American order principles- self.order_principles = {- "liberal_internationalism": {- "principle": "Rules-based international order",- "institutions": "UN, WTO, IMF, World Bank",- "values": "Democracy, human rights, free markets",- "current_challenges": "Rising authoritarianism, trade wars"- },- "democratic_promotion": {- "principle": "Democratic peace theory",- "strategy": "Democracy promotion abroad",- "tension": "Idealism vs realpolitik",- "current_challenges": "Failed interventions, illiberal democracies"- },- "american_exceptionalism": {- "principle": "Unique American role in world affairs",- "manifest_destiny": "Leadership of free world",- "burden": "Global policeman role",- "current_challenges": "War fatigue, isolationism"- },- "institutional_framework": {- "principle": "Multilateral institutions",- "nato": "Collective security in Europe",- "alliances": "Hub-and-spoke in Asia",- "current_challenges": "Burden-sharing, relevance"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Kissinger's American world order lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-American World Order Principles (Kissinger):-{self._format_principles()}--Query: {query}--Analyze through American world order framework.-"""- return context-- def _format_principles(self) -> str:- """Format order principles for context"""- formatted = []- for name, data in self.order_principles.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Principle: {data['principle']}")- formatted.append(f" Current: {data.get('current_challenges', 'N/A')}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="American World Order Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = AmericanOrderAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/islamic_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/islamic_order_agent.pydeleted file mode 100644index eb36930d1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/islamic_order_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Kissinger's Framework (FinAgent Core)-Based on "World Order" by Henry Kissinger--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--KISSINGER THESIS: American world order based on liberal internationalism,-democratic values, and post-WWII institutional framework.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class AmericanOrderAgent:- """- American World Order Agent using FinAgent Core-- Analyzes events through:- - Liberal internationalist principles- - Democratic value promotion- - American exceptionalism- - Post-WWII institutions (UN, NATO, IMF, World Bank)- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("world_order_american")-- if not self.config:- raise ValueError("American world order agent config not found in JSON")-- # American order principles- self.order_principles = {- "liberal_internationalism": {- "principle": "Rules-based international order",- "institutions": "UN, WTO, IMF, World Bank",- "values": "Democracy, human rights, free markets",- "current_challenges": "Rising authoritarianism, trade wars"- },- "democratic_promotion": {- "principle": "Democratic peace theory",- "strategy": "Democracy promotion abroad",- "tension": "Idealism vs realpolitik",- "current_challenges": "Failed interventions, illiberal democracies"- },- "american_exceptionalism": {- "principle": "Unique American role in world affairs",- "manifest_destiny": "Leadership of free world",- "burden": "Global policeman role",- "current_challenges": "War fatigue, isolationism"- },- "institutional_framework": {- "principle": "Multilateral institutions",- "nato": "Collective security in Europe",- "alliances": "Hub-and-spoke in Asia",- "current_challenges": "Burden-sharing, relevance"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Kissinger's American world order lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-American World Order Principles (Kissinger):-{self._format_principles()}--Query: {query}--Analyze through American world order framework.-"""- return context-- def _format_principles(self) -> str:- """Format order principles for context"""- formatted = []- for name, data in self.order_principles.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Principle: {data['principle']}")- formatted.append(f" Current: {data.get('current_challenges', 'N/A')}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="American World Order Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = AmericanOrderAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/multipolar_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/multipolar_order_agent.pydeleted file mode 100644index eb36930d1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/multipolar_order_agent.py+++ /dev/null@@ -1,111 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Kissinger's Framework (FinAgent Core)-Based on "World Order" by Henry Kissinger--This agent uses finagent_core for LLM execution.-All configuration is in GeopoliticsAgents/configs/agent_definitions.json--KISSINGER THESIS: American world order based on liberal internationalism,-democratic values, and post-WWII institutional framework.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class AmericanOrderAgent:- """- American World Order Agent using FinAgent Core-- Analyzes events through:- - Liberal internationalist principles- - Democratic value promotion- - American exceptionalism- - Post-WWII institutions (UN, NATO, IMF, World Bank)- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent.parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("world_order_american")-- if not self.config:- raise ValueError("American world order agent config not found in JSON")-- # American order principles- self.order_principles = {- "liberal_internationalism": {- "principle": "Rules-based international order",- "institutions": "UN, WTO, IMF, World Bank",- "values": "Democracy, human rights, free markets",- "current_challenges": "Rising authoritarianism, trade wars"- },- "democratic_promotion": {- "principle": "Democratic peace theory",- "strategy": "Democracy promotion abroad",- "tension": "Idealism vs realpolitik",- "current_challenges": "Failed interventions, illiberal democracies"- },- "american_exceptionalism": {- "principle": "Unique American role in world affairs",- "manifest_destiny": "Leadership of free world",- "burden": "Global policeman role",- "current_challenges": "War fatigue, isolationism"- },- "institutional_framework": {- "principle": "Multilateral institutions",- "nato": "Collective security in Europe",- "alliances": "Hub-and-spoke in Asia",- "current_challenges": "Burden-sharing, relevance"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Kissinger's American world order lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- """- context = f"""-American World Order Principles (Kissinger):-{self._format_principles()}--Query: {query}--Analyze through American world order framework.-"""- return context-- def _format_principles(self) -> str:- """Format order principles for context"""- formatted = []- for name, data in self.order_principles.items():- formatted.append(f"\n{name.upper()}:")- formatted.append(f" Principle: {data['principle']}")- formatted.append(f" Current: {data.get('current_challenges', 'N/A')}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="American World Order Agent")- parser.add_argument("--query", required=True, help="Query to analyze")-- args = parser.parse_args(argv)-- agent = AmericanOrderAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/benjamin_graham_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/benjamin_graham_agent.pydeleted file mode 100644index 2ea6aaa50..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/benjamin_graham_agent.py+++ /dev/null@@ -1,120 +0,0 @@-"""-BENJAMIN GRAHAM AGENT - Deep Value Framework (FinAgent Core)-Based on Benjamin Graham's investment philosophy--This agent uses finagent_core for LLM execution.-All configuration is in TraderInvestorsAgent/configs/agent_definitions.json--GRAHAM PHILOSOPHY: Margin of safety principle - buy assets trading below intrinsic value-with significant discount for protection against downside risk.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class BenjaminGrahamAgent:- """- Benjamin Graham Agent using FinAgent Core-- Deep value principles analyzed:- - Margin of safety → price significantly below intrinsic value- - Quantitative rigor → statistical bargains- - Net-net working capital → asset-based valuation- - Defensive characteristics → financial safety- - Mr. Market behavior → exploit market irrationality- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("benjamin_graham_agent")-- if not self.config:- raise ValueError("Benjamin Graham agent config not found in JSON")-- # Graham's investment criteria- self.investment_criteria = {- "margin_of_safety": {- "indicator": "Price vs intrinsic value discount",- "importance": "Critical - core principle",- "evaluation": "P/B ratio, asset coverage",- "threshold": "Price <67% of intrinsic value (50% discount)"- },- "net_net_working_capital": {- "indicator": "Current assets - total liabilities",- "importance": "High - statistical bargain",- "evaluation": "Market cap vs NCAV",- "threshold": "Price <NCAV (negative enterprise value)"- },- "defensive_characteristics": {- "indicator": "Financial safety measures",- "importance": "High - protect downside",- "evaluation": "Current ratio, debt levels, earnings stability",- "threshold": "Current ratio >2, D/E <0.5, profitable 5+ years"- },- "earnings_yield": {- "indicator": "Earnings power relative to price",- "importance": "Medium - valuation metric",- "evaluation": "E/P ratio vs bond yields",- "threshold": "E/P ratio >2x AAA bond yield"- },- "dividend_record": {- "indicator": "Consistent dividend payments",- "importance": "Low - income component",- "evaluation": "Dividend history",- "threshold": "Uninterrupted dividends 20+ years"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Graham's deep value lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Investment Criteria (Benjamin Graham Framework):-{self._format_criteria()}--Query: {query}--Analyze this through Graham's margin of safety principle, seeking statistical bargains.-"""- return context-- def _format_criteria(self) -> str:- """Format investment criteria for context"""- formatted = []- for name, data in self.investment_criteria.items():- formatted.append(f"\n{name.upper().replace('_', ' ')}:")- formatted.append(f" Indicator: {data['indicator']}")- formatted.append(f" Importance: {data['importance']}")- formatted.append(f" Threshold: {data['threshold']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Benjamin Graham Agent")- parser.add_argument("--query", required=True, help="Investment query to analyze")-- args = parser.parse_args(argv)-- agent = BenjaminGrahamAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/warren_buffett_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/warren_buffett_agent.pydeleted file mode 100644index 8632b2757..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/TraderInvestorsAgent/warren_buffett_agent.py+++ /dev/null@@ -1,120 +0,0 @@-"""-WARREN BUFFETT AGENT - Value Investing Framework (FinAgent Core)-Based on Warren Buffett's investment philosophy--This agent uses finagent_core for LLM execution.-All configuration is in TraderInvestorsAgent/configs/agent_definitions.json--BUFFETT PHILOSOPHY: Buy wonderful companies at fair prices - focus on economic moats,-predictable earnings, strong management, and long-term value creation.-"""--import sys-from pathlib import Path-from typing import Dict, Any--# Add parent directories to path-sys.path.insert(0, str(Path(__file__).parent.parent.parent))--from finagent_core.base_agent import AgentRegistry--class WarrenBuffettAgent:- """- Warren Buffett Agent using FinAgent Core-- Investment principles analyzed:- - Economic moats → sustainable competitive advantages- - Predictable earnings → consistent profitability- - Financial fortress → strong balance sheets- - Quality management → efficient capital allocation- - Fair price → owner earnings yield- """-- def __init__(self, config_path: Path = None):- if config_path is None:- config_path = Path(__file__).parent / "configs" / "agent_definitions.json"-- registry = AgentRegistry(config_path)- self.config = registry.get_agent("warren_buffett_agent")-- if not self.config:- raise ValueError("Warren Buffett agent config not found in JSON")-- # Buffett's investment criteria- self.investment_criteria = {- "economic_moat": {- "indicator": "High ROE (15%+), pricing power",- "importance": "Critical - sustainable competitive advantage",- "evaluation": "Brand strength, network effects, cost advantages",- "threshold": "ROE >15% for 7+ years"- },- "predictable_earnings": {- "indicator": "Consistent profitability over decade",- "importance": "High - avoid cyclical businesses",- "evaluation": "Earnings stability, growth trend",- "threshold": "Positive earnings 8+ of 10 years"- },- "financial_fortress": {- "indicator": "Low debt, strong cash flow",- "importance": "High - financial safety",- "evaluation": "D/E ratio, current ratio, FCF",- "threshold": "D/E <0.3, consistent positive FCF"- },- "quality_management": {- "indicator": "Capital allocation skill",- "importance": "Medium - effective reinvestment",- "evaluation": "Share buybacks, retained earnings growth",- "threshold": "Shareholder-friendly decisions"- },- "fair_valuation": {- "indicator": "Owner earnings yield",- "importance": "Medium - buy at reasonable price",- "evaluation": "FCF yield, P/E ratio",- "threshold": "FCF yield >5%, P/E <25"- }- }-- def analyze(self, query: str) -> str:- """- Analyze query through Buffett's value investing lens-- Note: LLM execution happens via finagent_core (tauri_bridge.py)- This method is for direct Python usage if needed.- """- context = f"""-Investment Criteria (Warren Buffett Framework):-{self._format_criteria()}--Query: {query}--Analyze this through Buffett's philosophy, focusing on long-term business quality.-"""- return context-- def _format_criteria(self) -> str:- """Format investment criteria for context"""- formatted = []- for name, data in self.investment_criteria.items():- formatted.append(f"\n{name.upper().replace('_', ' ')}:")- formatted.append(f" Indicator: {data['indicator']}")- formatted.append(f" Importance: {data['importance']}")- formatted.append(f" Threshold: {data['threshold']}")- return "\n".join(formatted)---def main(argv=None):- """CLI entry point for testing"""- import argparse-- parser = argparse.ArgumentParser(description="Warren Buffett Agent")- parser.add_argument("--query", required=True, help="Investment query to analyze")-- args = parser.parse_args(argv)-- agent = WarrenBuffettAgent()- result = agent.analyze(args.query)- print(result)---if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/core_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/core_agent.pyindex 264a274f2..7fc5fc2b3 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/core_agent.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/core_agent.py@@ -494,13 +494,40 @@ class CoreAgent:# 4. Tools - Load and validate# =================================================================tool_names = config.get("tools", [])+ all_tools = []+if tool_names:tools = ToolsRegistry.get_tools(tool_names, api_keys=self.api_keys)- if tools:- agent_kwargs["tools"] = tools- else:+ all_tools.extend(tools)+ if not tools:logger.warning(f"No tools loaded from: {tool_names}")+ # MCP servers — user-configured servers from the MCP tab+ # Format: [{"id", "name", "command", "args", "env", "transport"}]+ mcp_servers = config.get("mcp_servers", [])+ if mcp_servers:+ mcp_tools = self._connect_mcp_servers(mcp_servers)+ all_tools.extend(mcp_tools)++ # Terminal MCP bridge — TypeScript internal tools (navigation, market data, portfolio, etc.)+ # endpoint is injected by agents.rs when the bridge is running+ terminal_endpoint = config.get("terminal_mcp_endpoint")+ terminal_tool_defs = config.get("terminal_tools", [])+ if terminal_endpoint and terminal_tool_defs:+ try:+ from finagent_core.tools.terminal_toolkit import TerminalToolkit+ terminal_toolkit = TerminalToolkit(+ endpoint=terminal_endpoint,+ tool_definitions=terminal_tool_defs,+ )+ all_tools.extend(terminal_toolkit.get_tools())+ logger.info(f"TerminalToolkit: {len(terminal_toolkit.functions)} tools from TypeScript MCP")+ except Exception as e:+ logger.warning(f"TerminalToolkit setup failed: {e}")++ if all_tools:+ agent_kwargs["tools"] = all_tools+# =================================================================# 5. Memory Integration# =================================================================@@ -563,7 +590,21 @@ class CoreAgent:agent_kwargs["structured_outputs"] = config["structured_outputs"]# =================================================================- # 9. Output Settings+ # 9. Agentic Loop — CRITICAL for true autonomous operation+ # tool_call_limit caps how many tool iterations the agent+ # can make per run, preventing infinite loops while still+ # allowing multi-step autonomous tool use.+ # stream_intermediate_steps surfaces each tool call as it happens.+ # =================================================================+ if all_tools:+ # Cap tool call iterations — default 10, max 20+ max_iter = min(int(config.get("max_iterations", 10)), 20)+ agent_kwargs["tool_call_limit"] = max_iter+ # Surface intermediate reasoning/tool steps in streaming+ agent_kwargs["stream_intermediate_steps"] = True++ # =================================================================+ # 10. Output Settings# =================================================================if config.get("markdown", True):agent_kwargs["markdown"] = True@@ -571,11 +612,8 @@ class CoreAgent:if config.get("debug"):agent_kwargs["debug_mode"] = True- if config.get("show_tool_calls"):- agent_kwargs["show_tool_calls"] = True-# =================================================================- # 10. Session/Storage for persistence+ # 11. Session/Storage for persistence# =================================================================if config.get("session_id") or config.get("storage"):storage = self._create_storage(config)@@ -614,6 +652,104 @@ class CoreAgent:logger.error(f"Failed to create memory backend: {e}")return None+ def _connect_mcp_servers(self, mcp_servers: List[Dict[str, Any]]) -> List[Any]:+ """+ Connect to user-configured MCP servers from the MCP tab and return+ initialized MCPTools instances ready for use by the agent.++ Each entry in mcp_servers should have:+ - command (str): executable + args as a single string, or+ - cmd (str) + args (list): separate command and arguments+ - env (dict, optional): environment variables+ - transport ("stdio" | "sse" | "streamable-http", default "stdio")+ - url (str): required for sse/streamable-http transport+ - name (str, optional): server name for logging+ - id (str, optional): server id for tool_name_prefix++ Returns list of connected MCPTools instances (failures are skipped).+ """+ import asyncio+ connected = []++ for srv in mcp_servers:+ srv_name = srv.get("name") or srv.get("id") or "mcp-server"+ transport = srv.get("transport", "stdio")++ try:+ from agno.tools.mcp import MCPTools++ env = srv.get("env") or {}+ tool_prefix = (srv.get("id") or "").replace("-", "_") or None++ if transport in ("sse", "streamable-http"):+ url = srv.get("url")+ if not url:+ logger.warning(f"MCP server '{srv_name}' missing url for {transport} transport — skipping")+ continue+ mcp_tool = MCPTools(+ url=url,+ transport=transport,+ env=env or None,+ tool_name_prefix=tool_prefix,+ timeout_seconds=30,+ )+ else:+ # stdio — build full command string from command + args+ cmd_parts = []+ if srv.get("command"):+ cmd_parts.append(srv["command"])+ if srv.get("args"):+ args = srv["args"]+ if isinstance(args, list):+ cmd_parts.extend(args)+ elif isinstance(args, str):+ cmd_parts.extend(args.split())+ if not cmd_parts:+ logger.warning(f"MCP server '{srv_name}' has no command — skipping")+ continue+ full_command = " ".join(cmd_parts)+ mcp_tool = MCPTools(+ command=full_command,+ env=env or None,+ transport="stdio",+ tool_name_prefix=tool_prefix,+ timeout_seconds=30,+ )++ # Connect synchronously using asyncio+ async def _connect(tool):+ await tool.connect()++ try:+ loop = asyncio.get_event_loop()+ if loop.is_running():+ # We're inside an event loop — use run_until_complete via thread+ import concurrent.futures+ with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:+ future = ex.submit(asyncio.run, _connect(mcp_tool))+ future.result(timeout=35)+ else:+ loop.run_until_complete(_connect(mcp_tool))+ except Exception as connect_err:+ logger.error(f"MCP server '{srv_name}' connect failed: {connect_err}")+ continue++ if mcp_tool.initialized:+ fn_count = len(mcp_tool.functions) if mcp_tool.functions else 0+ logger.info(f"MCP server '{srv_name}' connected — {fn_count} tools available")+ connected.append(mcp_tool)+ else:+ logger.warning(f"MCP server '{srv_name}' did not initialize properly")++ except ImportError:+ logger.warning("agno.tools.mcp not available — MCP servers cannot be used")+ break+ except Exception as e:+ logger.error(f"MCP server '{srv_name}' setup error: {e}")+ continue++ return connected+def _create_storage(self, config: Dict[str, Any]) -> Optional[Any]:"""Create storage backend for session persistence."""try:diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/main.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/main.pyindex 2a0855806..a9364c0ab 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/main.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/main.py@@ -116,9 +116,14 @@ def main(args=None):try:if len(args) == 0:- return json.dumps({"success": False, "error": "No payload provided"})+ # Read payload from stdin (used when payload is too large for argv)+ payload_str = sys.stdin.read().strip()+ if not payload_str:+ return json.dumps({"success": False, "error": "No payload provided"})+ else:+ payload_str = args[0]- payload = json.loads(args[0])+ payload = json.loads(payload_str)action = payload.get("action")api_keys = payload.get("api_keys", {})params = payload.get("params", {})@@ -626,6 +631,71 @@ def dispatch_action(models = agent.list_output_models()return {"success": True, "models": models}+ # =========================================================================+ # Resumable Multi-Step Agentic Tasks+ # =========================================================================++ if action == "start_task":+ """+ Start a multi-step autonomous task with full checkpoint persistence.+ The agent plans its own steps, executes each one with tools,+ and saves state after every step so it can be resumed if interrupted.++ Params: { query, session_id? }+ Config: standard agent config (model, tools, instructions, etc.)+ Returns: { success, task_id, response, steps_completed, steps }+ """+ from finagent_core.task_state import ResumableTaskRunner+ query = params.get("query")+ if not query:+ return {"success": False, "error": "Missing 'query' in params"}+ runner = ResumableTaskRunner(api_keys=api_keys)+ return runner.start_task(query, config)++ if action == "resume_task":+ """+ Resume a failed or interrupted multi-step task from its last checkpoint.+ Skips steps that already completed; continues from where it left off.++ Params: { task_id }+ Returns: { success, task_id, response, resumed_from_step, steps_completed }+ """+ from finagent_core.task_state import ResumableTaskRunner+ task_id = params.get("task_id")+ if not task_id:+ return {"success": False, "error": "Missing 'task_id' in params"}+ runner = ResumableTaskRunner(api_keys=api_keys)+ return runner.resume_task(task_id)++ if action == "get_task":+ """Get the current state of a task."""+ from finagent_core.task_state import get_state_manager+ task_id = params.get("task_id")+ if not task_id:+ return {"success": False, "error": "Missing 'task_id' in params"}+ task = get_state_manager().get_task(task_id)+ if not task:+ return {"success": False, "error": f"Task {task_id} not found"}+ return {"success": True, "task": task}++ if action == "list_tasks":+ """List recent tasks, optionally filtered by status."""+ from finagent_core.task_state import get_state_manager+ tasks = get_state_manager().list_tasks(+ status=params.get("status"),+ limit=params.get("limit", 20)+ )+ return {"success": True, "tasks": tasks, "count": len(tasks)}++ if action == "delete_task":+ """Delete a task by ID."""+ from finagent_core.task_state import get_state_manager+ task_id = params.get("task_id")+ if not task_id:+ return {"success": False, "error": "Missing 'task_id' in params"}+ get_state_manager().delete_task(task_id)+ return {"success": True, "deleted": task_id}+# =========================================================================# Unknown Action# =========================================================================diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/fincept_model.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/fincept_model.pyindex 8a130757d..80f181279 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/fincept_model.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/fincept_model.py@@ -1,12 +1,23 @@"""Fincept LLM Model - Custom adapter for Fincept's built-in LLM endpoint.-Subclasses agno's Model @dataclass to work with Agent.run().+The /research/llm endpoint wraps GLM (via Anthropic API format at z.ai):+ - Accepts: prompt (str), tools (list), tool_choice (dict)+ - Returns: {"data": {"response": str, "tool_calls": [...], "model": ...}}+ - tool_calls format: [{"id", "type": "function", "function": {"name", "arguments": json_str}}]++This adapter:+ 1. Converts Agno Function objects → Anthropic-style tool schemas+ 2. Sends them with the prompt to /research/llm+ 3. Parses tool_use blocks from the response+ 4. Executes the tools via Function.entrypoint+ 5. Loops with tool results until the model produces a final text response"""import httpx+import jsonimport logging-from dataclasses import dataclass, field+from dataclasses import dataclassfrom typing import Any, Optional, Dict, List, Iterator, AsyncIteratorfrom agno.models.base import Model@@ -18,39 +29,136 @@ logger = logging.getLogger(__name__)FINCEPT_DEFAULT_URL = "https://finceptbackend.share.zrok.io/research/llm"+# ── Anthropic tool schema builder ─────────────────────────────────────────────++def _function_to_anthropic_tool(fn: Any) -> Dict[str, Any]:+ """+ Convert an Agno Function object to Anthropic tool schema format.++ Anthropic format:+ {+ "name": "tool_name",+ "description": "...",+ "input_schema": {+ "type": "object",+ "properties": {"param": {"type": "string", "description": "..."}},+ "required": ["param"]+ }+ }+ """+ name = fn.name if hasattr(fn, "name") else str(fn)+ description = ""+ if hasattr(fn, "description") and fn.description:+ description = str(fn.description).strip()++ # Try to get parameter schema from Agno Function+ input_schema: Dict[str, Any] = {"type": "object", "properties": {}}++ if hasattr(fn, "parameters") and fn.parameters:+ params = fn.parameters+ if isinstance(params, dict):+ # Agno stores parameters as JSON schema already+ input_schema = params+ elif hasattr(params, "model_json_schema"):+ input_schema = params.model_json_schema()+ elif hasattr(fn, "entrypoint") and callable(fn.entrypoint):+ # Derive from function signature+ import inspect+ try:+ sig = inspect.signature(fn.entrypoint)+ props: Dict[str, Any] = {}+ required: List[str] = []+ for pname, param in sig.parameters.items():+ if pname in ("self", "agent", "team", "run_context"):+ continue+ ptype = "string"+ if param.annotation != inspect.Parameter.empty:+ ann = param.annotation+ if ann in (int,):+ ptype = "integer"+ elif ann in (float,):+ ptype = "number"+ elif ann in (bool,):+ ptype = "boolean"+ props[pname] = {"type": ptype}+ if param.default is inspect.Parameter.empty:+ required.append(pname)+ input_schema = {"type": "object", "properties": props}+ if required:+ input_schema["required"] = required+ except Exception:+ pass++ return {+ "name": name,+ "description": description or f"Tool: {name}",+ "input_schema": input_schema,+ }+++# ─────────────────────────────────────────────────────────────────────────────+@dataclassclass FinceptChat(Model):"""- Agno-compatible model for Fincept's built-in LLM endpoint.- Uses @dataclass inheritance matching agno's Model base class.+ Agno-compatible model for Fincept's /research/llm endpoint.++ Supports native function calling — the endpoint wraps GLM via+ Anthropic's API format, so tool schemas and tool_use responses+ work identically to the Anthropic SDK.++ Tool-calling loop:+ 1. Send prompt + Anthropic-format tool schemas+ 2. If response contains tool_calls → execute them via Function.entrypoint+ 3. Append tool results and call again+ 4. Repeat until plain text response (no tool_calls)"""id: str = "fincept-llm"name: str = "FinceptChat"provider: str = "Fincept"- # Fincept-specific fieldsapi_key: Optional[str] = Nonebase_url: str = FINCEPT_DEFAULT_URLtemperature: Optional[float] = Nonemax_tokens: Optional[int] = None- def _make_request(self, messages: List[Message]) -> Dict[str, Any]:- """Send request to Fincept endpoint and return raw response dict."""- # Fincept endpoint expects a single 'prompt' field, not 'messages'- prompt = self._messages_to_prompt(messages)+ # Max tool call rounds before forcing a final answer+ max_tool_rounds: int = 8++ # ── HTTP request ──────────────────────────────────────────────────────────+ def _call_endpoint(+ self,+ prompt: str,+ tools: Optional[List[Dict]] = None,+ tool_choice: Optional[Dict] = None,+ tool_results_context: Optional[str] = None,+ ) -> Dict[str, Any]:+ """+ Call /research/llm and return the parsed response dict.++ Returns the full data dict:+ {"response": str, "tool_calls": [...], "model": str, ...}+ """headers = {"Content-Type": "application/json"}if self.api_key:headers["X-API-Key"] = self.api_key- payload: Dict[str, Any] = {- "prompt": prompt,- }+ # Build the full prompt — include tool results from prior rounds+ full_prompt = prompt+ if tool_results_context:+ full_prompt = f"{prompt}\n\n{tool_results_context}"++ payload: Dict[str, Any] = {"prompt": full_prompt}if self.temperature is not None:payload["temperature"] = self.temperatureif self.max_tokens is not None:payload["max_tokens"] = self.max_tokens+ if tools:+ payload["tools"] = tools+ if tool_choice:+ payload["tool_choice"] = tool_choicetry:with httpx.Client(timeout=120.0) as client:@@ -63,9 +171,15 @@ class FinceptChat(Model):error_detail = err_data.get("detail", err_data.get("message", ""))except Exception:error_detail = resp.text[:200]- raise RuntimeError(f"Fincept API error ({resp.status_code}): {error_detail}")+ raise RuntimeError(+ f"Fincept API error ({resp.status_code}): {error_detail}"+ )- return resp.json()+ outer = resp.json()+ # Unwrap: {"success": true, "data": {...}}+ if isinstance(outer, dict) and "data" in outer:+ return outer["data"]+ return outerexcept httpx.TimeoutException:raise RuntimeError("Fincept API request timed out (120s)")@@ -76,89 +190,265 @@ class FinceptChat(Model):except Exception as e:raise RuntimeError(f"Fincept API call failed: {e}")+ # ── Tool execution ────────────────────────────────────────────────────────++ def _execute_tool_call(+ self,+ tool_call: Dict[str, Any],+ functions: Dict[str, Any],+ ) -> str:+ """+ Execute a single tool call returned by the model.++ tool_call format:+ {"id": "...", "type": "function", "function": {"name": "...", "arguments": "json_str"}}+ """+ fn_info = tool_call.get("function", {})+ tool_name = fn_info.get("name", "")+ args_str = fn_info.get("arguments", "{}")++ try:+ args = json.loads(args_str) if isinstance(args_str, str) else args_str+ except Exception:+ args = {}++ fn = functions.get(tool_name)+ if fn is None:+ return f"Error: Tool '{tool_name}' not found. Available: {list(functions.keys())}"++ logger.info(f"FinceptChat: calling {tool_name}({args})")+ try:+ if hasattr(fn, "entrypoint") and callable(fn.entrypoint):+ result = fn.entrypoint(**args)+ elif callable(fn):+ result = fn(**args)+ else:+ return f"Error: '{tool_name}' is not callable"++ if result is None:+ return "Tool returned no result."+ if isinstance(result, (dict, list)):+ return json.dumps(result, indent=2, default=str)+ return str(result)+ except Exception as e:+ return f"Tool execution error for {tool_name}: {e}"++ # ── Native function-calling loop ──────────────────────────────────────────++ # Fincept endpoint hard limit is 50k chars.+ # We target 35k for the full prompt (prompt + tool context),+ # leaving headroom for system instructions and response.+ _PROMPT_CHAR_BUDGET = 35_000+ # Per-tool-result cap — prevents a single large result from dominating+ _TOOL_RESULT_CAP = 4_000++ def _run_tool_loop(+ self,+ prompt: str,+ tool_schemas: List[Dict],+ functions: Dict[str, Any],+ ) -> str:+ """+ Run the native tool-calling loop:+ 1. Call endpoint with tools+ 2. If tool_calls in response → execute → build results context → repeat+ 3. When no tool_calls → return response text++ Tool results are truncated to _TOOL_RESULT_CAP chars each, and the+ cumulative context is trimmed to stay within _PROMPT_CHAR_BUDGET.+ """+ tool_results_context = ""++ for round_num in range(self.max_tool_rounds):+ logger.debug(f"FinceptChat: tool round {round_num + 1}/{self.max_tool_rounds}")++ data = self._call_endpoint(+ prompt=prompt,+ tools=tool_schemas,+ tool_results_context=tool_results_context if tool_results_context else None,+ )++ response_text = data.get("response", "")+ tool_calls = data.get("tool_calls", [])++ logger.debug(+ f"FinceptChat: response={response_text[:100]!r}, "+ f"tool_calls={len(tool_calls)}"+ )++ if not tool_calls:+ # No more tool calls — we have the final answer+ return response_text++ # Execute all tool calls from this round+ results_parts = []+ for tc in tool_calls:+ call_id = tc.get("id", "unknown")+ fn_name = tc.get("function", {}).get("name", "unknown")+ raw_result = self._execute_tool_call(tc, functions)++ # Truncate large tool results to stay within prompt budget+ if len(raw_result) > self._TOOL_RESULT_CAP:+ raw_result = (+ raw_result[:self._TOOL_RESULT_CAP]+ + f"\n... [truncated — {len(raw_result)} chars total]"+ )++ results_parts.append(+ f"Tool result for {fn_name} (id={call_id}):\n{raw_result}"+ )+ logger.debug(f"Tool {fn_name} result: {raw_result[:200]}")++ new_results = "\n\n".join(results_parts)++ # Build updated context and trim if over budget+ candidate = (+ (tool_results_context + "\n\n" + new_results).strip()+ if tool_results_context+ else f"Tool results:\n{new_results}"+ )+ # Keep only the most recent content if over budget+ budget = self._PROMPT_CHAR_BUDGET - len(prompt) - 500 # 500 for overhead+ if len(candidate) > budget > 0:+ candidate = candidate[-budget:]+ candidate = "... [older results trimmed]\n" + candidate+ tool_results_context = candidate++ # Hit round limit — synthesize from accumulated context+ logger.warning(+ f"FinceptChat: hit tool round limit ({self.max_tool_rounds}), "+ "requesting final synthesis"+ )+ synthesis_prompt = (+ f"{prompt}\n\n{tool_results_context}\n\n"+ "Based on the tool results above, provide a complete final answer."+ )+ data = self._call_endpoint(prompt=synthesis_prompt)+ return data.get("response", "")++ # ── Override Model.response() ─────────────────────────────────────────────++ def response(+ self,+ messages: List[Message],+ response_format=None,+ tools=None,+ tool_choice=None,+ tool_call_limit=None,+ run_response=None,+ send_media_to_model: bool = True,+ compression_manager=None,+ **kwargs,+ ) -> ModelResponse:+ """+ Override base response() to use Fincept's native function calling.++ When Agno passes Function objects via `tools`, convert them to+ Anthropic-format schemas and run the tool loop. Otherwise do a+ simple completion.+ """+ from agno.tools.function import Function++ # Build functions dict from Agno Function objects+ _functions: Dict[str, Any] = {}+ _tool_schemas: List[Dict] = []++ if tools:+ for t in tools:+ if isinstance(t, Function) and t.entrypoint:+ _functions[t.name] = t+ _tool_schemas.append(_function_to_anthropic_tool(t))++ # Build prompt from messages+ prompt = self._messages_to_prompt(messages)++ if _functions:+ logger.info(+ f"FinceptChat: native tool calling with "+ f"{len(_functions)} tools: {list(_functions.keys())}"+ )+ answer = self._run_tool_loop(+ prompt=prompt,+ tool_schemas=_tool_schemas,+ functions=_functions,+ )+ return ModelResponse(content=answer, role="assistant")++ # No tools — simple completion+ data = self._call_endpoint(prompt=prompt)+ content = data.get("response", str(data))+ return ModelResponse(content=content, role="assistant")++ # ── Agno Model interface ──────────────────────────────────────────────────+def invoke(self, *args, **kwargs) -> ModelResponse:- """Send request to Fincept endpoint and return ModelResponse."""- # Extract messages from args or kwargs+ """Simple completion — called by base class when no tool override needed."""messages = args[0] if args else kwargs.get("messages", [])- raw = self._make_request(messages)- return self._parse_provider_response(raw)+ prompt = self._messages_to_prompt(messages)+ data = self._call_endpoint(prompt=prompt)+ content = data.get("response", str(data))+ return ModelResponse(content=content, role="assistant")async def ainvoke(self, *args, **kwargs) -> ModelResponse:- """Async invoke - runs sync version in executor."""import asyncioloop = asyncio.get_event_loop()return await loop.run_in_executor(None, lambda: self.invoke(*args, **kwargs))def invoke_stream(self, *args, **kwargs) -> Iterator[ModelResponse]:- """Streaming not supported - yield single response."""yield self.invoke(*args, **kwargs)async def ainvoke_stream(self, *args, **kwargs) -> AsyncIterator[ModelResponse]:- """Async streaming - yields single result."""result = await self.ainvoke(*args, **kwargs)yield resultdef _parse_provider_response(self, response: Any, **kwargs) -> ModelResponse:- """Parse raw provider response into ModelResponse."""content = self._extract_content(response)return ModelResponse(content=content, role="assistant")def _parse_provider_response_delta(self, response: Any) -> ModelResponse:- """Parse streaming delta into ModelResponse."""- content = self._extract_content(response) if isinstance(response, dict) else (str(response) if response else "")+ content = (+ self._extract_content(response)+ if isinstance(response, dict)+ else (str(response) if response else "")+ )return ModelResponse(content=content, role="assistant")+ # ── Helpers ───────────────────────────────────────────────────────────────+def _messages_to_prompt(self, messages: List[Message]) -> str:- """Convert agno Messages list into a single prompt string for the Fincept API."""+ """Convert Agno Message list to a single prompt string."""parts = []for msg in messages:content = msg.content or ""if isinstance(content, list):- text_parts = [p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"]+ text_parts = [+ p.get("text", "")+ for p in content+ if isinstance(p, dict) and p.get("type") == "text"+ ]content = "\n".join(text_parts) if text_parts else str(content)content = str(content).strip()if not content:continue-- role = msg.role or "user"+ role = getattr(msg, "role", "user") or "user"if role == "system":parts.append(f"[System]: {content}")- elif role == "user":- parts.append(content)elif role == "assistant":parts.append(f"[Assistant]: {content}")else:parts.append(content)-return "\n\n".join(parts)def _extract_content(self, data: Any) -> str:- """Extract text content from various response formats."""+ """Extract text from various response formats."""if isinstance(data, dict):- # Fincept API format: {"success": true, "data": {"response": "..."}}+ # Fincept: {"success": true, "data": {"response": "..."}}if "data" in data and isinstance(data["data"], dict):- if "response" in data["data"]:- return str(data["data"]["response"])-- # OpenAI-style format- if "choices" in data:- choices = data["choices"]- if choices:- msg = choices[0].get("message", {})- return msg.get("content", "")-- # Other common formats- if "response" in data:- return str(data["response"])- if "content" in data:- return str(data["content"])- if "text" in data:- return str(data["text"])- if "answer" in data:- return str(data["answer"])-+ return str(data["data"].get("response", ""))+ for key in ("response", "content", "text", "answer"):+ if key in data:+ return str(data[key])return str(data)-return str(data) if data else ""def get_provider(self) -> str:diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/tools_registry.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/tools_registry.pyindex 8db5c6905..6976f0bb0 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/tools_registry.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/registries/tools_registry.py@@ -18,6 +18,11 @@ class ToolsRegistry:# Tool categories and their available toolsTOOL_CATALOG = {+ # SEC EDGAR (internal Fincept MCP — no API key required)+ "sec_edgar": {+ "edgar": "finagent_core.tools.edgar_tools.EdgarTools",+ },+# Finance & Trading"finance": {"yfinance": "agno.tools.yfinance.YFinanceTools",diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/super_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/super_agent.pyindex 7c6fa63c8..1bb61bd25 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/super_agent.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/super_agent.py@@ -2,10 +2,14 @@SuperAgent - Triage routing for query distributionRoutes queries to appropriate sub-agents based on intent classification.-Similar to ValueCell's agent orchestration pattern.+Supports two routing modes:+ - LLM-based routing (default): The LLM itself decides which agent/intent fits best.+ This is fully agentic — no hardcoded keyword tables.+ - Keyword fallback: Used when no LLM config is available (offline / no API key)."""import re+import jsonfrom typing import Dict, Any, Optional, List, Callablefrom dataclasses import dataclass, fieldfrom enum import Enum@@ -13,6 +17,23 @@ import logginglogger = logging.getLogger(__name__)+# System prompt given to the LLM router — lists all intents and asks for a JSON decision+LLM_ROUTER_SYSTEM_PROMPT = """You are a financial query router. Your ONLY job is to classify a user query into ONE of these intents and return a JSON object.++Available intents:+- trading: order execution, buy/sell signals, position entry/exit, market orders+- portfolio: portfolio allocation, rebalancing, diversification, holdings management+- analysis: stock/equity research, valuation (DCF, P/E), fundamental or technical analysis, price targets+- risk: VaR, volatility, drawdown, Sharpe ratio, hedging, stress testing, correlation+- news: market news, earnings announcements, press releases, headlines+- geopolitics: geopolitical risk, international relations, sanctions, trade wars, elections+- economics: GDP, inflation, interest rates, central banks, employment, CPI/PPI+- research: deep-dive research, industry studies, comprehensive investigation+- general: anything that doesn't fit the above++Respond ONLY with a valid JSON object in this exact format (no markdown, no explanation):+{"intent": "<intent>", "confidence": <0.0-1.0>, "reasoning": "<one sentence>"}"""+class QueryIntent(Enum):"""Classified query intents"""@@ -179,12 +200,105 @@ class IntentClassifier:return results+class LLMRouter:+ """+ True agentic router: asks an LLM to classify the query intent.++ Falls back to IntentClassifier (keyword-based) if:+ - No model config / API keys are available+ - LLM call fails or times out+ - LLM returns unparseable output+ """++ INTENT_VALUES = {i.value for i in QueryIntent}++ def __init__(+ self,+ model_config: Optional[Dict[str, Any]] = None,+ api_keys: Optional[Dict[str, str]] = None,+ ):+ self.model_config = model_config or {}+ self.api_keys = api_keys or {}+ self._fallback = IntentClassifier()++ def classify(self, query: str) -> tuple:+ """+ Classify query intent using LLM if available, else keyword fallback.++ Returns:+ (QueryIntent, confidence: float, reasoning: str)+ """+ provider = self.model_config.get("provider", "")+ model_id = self.model_config.get("model_id", "")++ if provider and model_id:+ try:+ return self._llm_classify(query, provider, model_id)+ except Exception as e:+ logger.warning(f"LLM routing failed, using keyword fallback: {e}")++ # Keyword fallback+ results = self._fallback.classify(query)+ if results:+ intent, confidence, _, _ = results[0]+ return intent, confidence, "keyword-based classification"+ return QueryIntent.GENERAL, 0.1, "no match found"++ def _llm_classify(self, query: str, provider: str, model_id: str) -> tuple:+ """Ask the LLM to classify the query. Returns (QueryIntent, confidence, reasoning)."""+ from finagent_core.registries import ModelsRegistry++ model = ModelsRegistry.create_model(+ provider=provider,+ model_id=model_id,+ api_keys=self.api_keys,+ temperature=0.0, # Deterministic — routing must be consistent+ )++ from agno.agent import Agent+ router_agent = Agent(+ model=model,+ instructions=LLM_ROUTER_SYSTEM_PROMPT,+ markdown=False,+ )++ response = router_agent.run(f"Classify this query: {query}")++ # Extract text+ if hasattr(response, "content"):+ text = response.content+ else:+ text = str(response)++ # Strip any accidental markdown code fences+ text = text.strip()+ if text.startswith("```"):+ text = text.split("```")[1]+ if text.startswith("json"):+ text = text[4:]+ text = text.strip()++ parsed = json.loads(text)+ intent_str = parsed.get("intent", "general").lower()+ confidence = float(parsed.get("confidence", 0.8))+ reasoning = parsed.get("reasoning", "")++ # Validate intent value+ if intent_str not in self.INTENT_VALUES:+ intent_str = "general"++ intent = QueryIntent(intent_str)+ logger.info(f"LLM routed '{query[:60]}' → {intent_str} (conf={confidence:.2f}): {reasoning}")+ return intent, confidence, reasoning++class SuperAgent:"""SuperAgent - Routes queries to appropriate sub-agents.Features:- - Intent classification+ - LLM-driven intent classification (true agentic routing)+ - Keyword fallback when LLM unavailable- Multi-agent routing- Fallback handling- Response aggregation@@ -193,10 +307,12 @@ class SuperAgent:def __init__(self,api_keys: Optional[Dict[str, str]] = None,- routes: Optional[List[RouteConfig]] = None+ routes: Optional[List[RouteConfig]] = None,+ model_config: Optional[Dict[str, Any]] = None,):self.api_keys = api_keys or {}- self.classifier = IntentClassifier()+ self.classifier = IntentClassifier() # keyword fallback+ self.llm_router = LLMRouter(model_config=model_config, api_keys=self.api_keys)self.routes: Dict[QueryIntent, RouteConfig] = {}self.fallback_agent_id = "core_agent"@@ -288,7 +404,8 @@ class SuperAgent:def route(self, query: str) -> RoutingResult:"""- Route query to appropriate agent.+ Route query to appropriate agent using LLM classification.+ Falls back to keyword matching if LLM is unavailable.Args:query: User query@@ -296,31 +413,16 @@ class SuperAgent:Returns:RoutingResult with agent info and confidence"""- # Classify intent- classifications = self.classifier.classify(query)-- if not classifications:- # Fallback to general- return RoutingResult(- intent=QueryIntent.GENERAL,- agent_id=self.fallback_agent_id,- confidence=0.0,- config={}- )-- # Get top classification- top_intent, confidence, matched_kw, matched_pt = classifications[0]-- # Get route config- route = self.routes.get(top_intent, self.routes.get(QueryIntent.GENERAL))+ intent, confidence, reasoning = self.llm_router.classify(query)+ route = self.routes.get(intent, self.routes.get(QueryIntent.GENERAL))return RoutingResult(- intent=top_intent,+ intent=intent,agent_id=route.agent_id if route else self.fallback_agent_id,confidence=confidence,config=route.config_override if route else {},- matched_keywords=matched_kw,- matched_patterns=matched_pt+ matched_keywords=[reasoning], # repurpose field to carry LLM reasoning+ matched_patterns=[],)def route_multi(self, query: str, max_agents: int = 3) -> List[RoutingResult]:@@ -376,7 +478,11 @@ class SuperAgent:from finagent_core.core_agent import CoreAgentfrom finagent_core.agent_loader import get_loader- # Route query+ # Pass user model config to LLM router so it can use the same provider+ if user_config and user_config.get("model"):+ self.llm_router.model_config = user_config["model"]++ # Route query (LLM-based)routing = self.route(query)logger.info(f"Routed to {routing.agent_id} with confidence {routing.confidence:.2f}")@@ -587,5 +693,6 @@ def execute_query(config: Dict[str, Any] = None) -> Dict[str, Any]:"""Route and execute a query"""- agent = SuperAgent(api_keys=api_keys)+ model_config = config.get("model") if config else None+ agent = SuperAgent(api_keys=api_keys, model_config=model_config)return agent.execute(query, session_id, user_config=config)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/task_state.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/task_state.pynew file mode 100644index 000000000..52a44fa8d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/task_state.py@@ -0,0 +1,416 @@+"""+TaskState - Persistent task state for autonomous multi-step agent operations.++Enables true agentic behavior by:+1. Saving task progress to SQLite after every step+2. Resuming a failed/interrupted task from the last checkpoint+3. Letting the agent pick up mid-task without re-running completed steps++This is what makes the agent truly autonomous — if it's running a 5-step+analysis and step 3 fails due to a network error, it can be resumed from+step 3 rather than starting over.++Storage format (SQLite):+ Table: agent_tasks+ id TEXT PRIMARY KEY+ query TEXT+ config_json TEXT -- agent config snapshot+ steps_json TEXT -- list of completed steps with results+ status TEXT -- pending | running | completed | failed | paused+ current_step INT+ result TEXT -- final result when status=completed+ error TEXT -- error message when status=failed+ created_at TEXT+ updated_at TEXT+"""++import json+import sqlite3+import uuid+from datetime import datetime+from pathlib import Path+from typing import Any, Dict, List, Optional+++# Default DB path — same directory as Agno's storage+_DEFAULT_DB = str(Path(__file__).parent.parent.parent / "agent_tasks.db")+++# ─── Schema ──────────────────────────────────────────────────────────────────++_CREATE_TABLE = """+CREATE TABLE IF NOT EXISTS agent_tasks (+ id TEXT PRIMARY KEY,+ query TEXT NOT NULL,+ config_json TEXT NOT NULL,+ steps_json TEXT NOT NULL DEFAULT '[]',+ status TEXT NOT NULL DEFAULT 'pending',+ current_step INTEGER NOT NULL DEFAULT 0,+ result TEXT,+ error TEXT,+ created_at TEXT NOT NULL,+ updated_at TEXT NOT NULL+)+"""+++# ─── TaskStateManager ────────────────────────────────────────────────────────++class TaskStateManager:+ """+ Manages persistent task state for resumable agentic operations.+ All state is stored in SQLite so it survives process restarts.+ """++ def __init__(self, db_path: str = _DEFAULT_DB):+ self.db_path = db_path+ self._ensure_table()++ def _conn(self) -> sqlite3.Connection:+ conn = sqlite3.connect(self.db_path)+ conn.row_factory = sqlite3.Row+ return conn++ def _ensure_table(self):+ with self._conn() as conn:+ conn.execute(_CREATE_TABLE)++ # ── CRUD ─────────────────────────────────────────────────────────────────++ def create_task(self, query: str, config: Dict[str, Any]) -> str:+ """Create a new task and return its ID."""+ task_id = str(uuid.uuid4())+ now = datetime.utcnow().isoformat()+ with self._conn() as conn:+ conn.execute(+ "INSERT INTO agent_tasks (id, query, config_json, steps_json, status, current_step, created_at, updated_at) "+ "VALUES (?, ?, ?, '[]', 'pending', 0, ?, ?)",+ (task_id, query, json.dumps(config), now, now)+ )+ return task_id++ def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:+ """Get task by ID."""+ with self._conn() as conn:+ row = conn.execute("SELECT * FROM agent_tasks WHERE id = ?", (task_id,)).fetchone()+ if not row:+ return None+ return self._row_to_dict(row)++ def list_tasks(self, status: Optional[str] = None, limit: int = 50) -> List[Dict[str, Any]]:+ """List tasks, optionally filtered by status."""+ with self._conn() as conn:+ if status:+ rows = conn.execute(+ "SELECT * FROM agent_tasks WHERE status = ? ORDER BY created_at DESC LIMIT ?",+ (status, limit)+ ).fetchall()+ else:+ rows = conn.execute(+ "SELECT * FROM agent_tasks ORDER BY created_at DESC LIMIT ?", (limit,)+ ).fetchall()+ return [self._row_to_dict(r) for r in rows]++ def update_status(self, task_id: str, status: str, error: Optional[str] = None):+ """Update task status."""+ now = datetime.utcnow().isoformat()+ with self._conn() as conn:+ conn.execute(+ "UPDATE agent_tasks SET status = ?, error = ?, updated_at = ? WHERE id = ?",+ (status, error, now, task_id)+ )++ def save_checkpoint(self, task_id: str, step_index: int, step_result: Dict[str, Any]):+ """+ Save a completed step as a checkpoint.+ The agent can be resumed from this point if it fails on a later step.+ """+ task = self.get_task(task_id)+ if not task:+ raise ValueError(f"Task {task_id} not found")++ steps = task["steps"]+ # Ensure we don't duplicate steps on retry+ if len(steps) <= step_index:+ steps.append(step_result)+ else:+ steps[step_index] = step_result++ now = datetime.utcnow().isoformat()+ with self._conn() as conn:+ conn.execute(+ "UPDATE agent_tasks SET steps_json = ?, current_step = ?, status = 'running', updated_at = ? WHERE id = ?",+ (json.dumps(steps), step_index + 1, now, task_id)+ )++ def complete_task(self, task_id: str, result: str):+ """Mark task as completed with final result."""+ now = datetime.utcnow().isoformat()+ with self._conn() as conn:+ conn.execute(+ "UPDATE agent_tasks SET status = 'completed', result = ?, updated_at = ? WHERE id = ?",+ (result, now, task_id)+ )++ def fail_task(self, task_id: str, error: str):+ """Mark task as failed — can be resumed later."""+ now = datetime.utcnow().isoformat()+ with self._conn() as conn:+ conn.execute(+ "UPDATE agent_tasks SET status = 'failed', error = ?, updated_at = ? WHERE id = ?",+ (error, now, task_id)+ )++ def delete_task(self, task_id: str):+ """Delete a task."""+ with self._conn() as conn:+ conn.execute("DELETE FROM agent_tasks WHERE id = ?", (task_id,))++ def _row_to_dict(self, row: sqlite3.Row) -> Dict[str, Any]:+ d = dict(row)+ d["config"] = json.loads(d.pop("config_json", "{}"))+ d["steps"] = json.loads(d.pop("steps_json", "[]"))+ return d+++# ─── Resumable Task Runner ────────────────────────────────────────────────────++class ResumableTaskRunner:+ """+ Runs a multi-step agentic task and persists state at every step.++ The task is broken into steps by the agent itself using a planning prompt.+ Each step result is checkpointed. If the process is interrupted, call+ resume_task() with the task_id to continue from the last checkpoint.+ """++ PLAN_PROMPT_TEMPLATE = """You are a financial AI assistant. The user's goal is:+"{query}"++Break this into a numbered list of concrete steps you will take to complete it.+Be specific. Each step should be independently executable.+Return ONLY a JSON array of step descriptions, e.g.:+["Fetch AAPL price data for last 12 months", "Calculate RSI and MACD indicators", "Identify support/resistance levels", "Generate buy/sell recommendation"]+"""++ def __init__(self, api_keys: Dict[str, str], db_path: str = _DEFAULT_DB):+ self.api_keys = api_keys+ self.state_mgr = TaskStateManager(db_path)++ def start_task(self, query: str, config: Dict[str, Any]) -> Dict[str, Any]:+ """+ Start a new multi-step task:+ 1. Ask the LLM to plan the steps+ 2. Save task state+ 3. Execute each step, checkpointing after each one+ 4. Return final synthesized result+ """+ task_id = self.state_mgr.create_task(query, config)+ self.state_mgr.update_status(task_id, "running")++ try:+ # Step 0: Plan the task+ steps = self._plan_steps(query, config)+ if not steps:+ steps = [query] # Single-step fallback++ all_results = []+ for i, step_desc in enumerate(steps):+ # Check if already done (resume scenario)+ task = self.state_mgr.get_task(task_id)+ if task and i < len(task["steps"]):+ # Already completed — skip+ all_results.append(task["steps"][i])+ continue++ step_result = self._execute_step(step_desc, query, config, i, all_results)+ self.state_mgr.save_checkpoint(task_id, i, step_result)+ all_results.append(step_result)++ # Synthesize final answer+ final = self._synthesize(query, all_results, config)+ self.state_mgr.complete_task(task_id, final)++ return {+ "success": True,+ "task_id": task_id,+ "response": final,+ "steps_completed": len(all_results),+ "steps": all_results,+ }++ except Exception as e:+ self.state_mgr.fail_task(task_id, str(e))+ return {"success": False, "task_id": task_id, "error": str(e)}++ def resume_task(self, task_id: str) -> Dict[str, Any]:+ """+ Resume a failed or paused task from its last checkpoint.+ Skips already-completed steps and continues from where it left off.+ """+ task = self.state_mgr.get_task(task_id)+ if not task:+ return {"success": False, "error": f"Task {task_id} not found"}++ if task["status"] == "completed":+ return {"success": True, "task_id": task_id, "response": task["result"], "already_completed": True}++ query = task["query"]+ config = task["config"]+ completed_steps = task["steps"]++ self.state_mgr.update_status(task_id, "running")++ try:+ # Re-plan to get full step list+ steps = self._plan_steps(query, config)+ if not steps:+ steps = [query]++ all_results = list(completed_steps) # Start with already-done steps++ for i, step_desc in enumerate(steps):+ if i < len(completed_steps):+ continue # Already done++ step_result = self._execute_step(step_desc, query, config, i, all_results)+ self.state_mgr.save_checkpoint(task_id, i, step_result)+ all_results.append(step_result)++ final = self._synthesize(query, all_results, config)+ self.state_mgr.complete_task(task_id, final)++ return {+ "success": True,+ "task_id": task_id,+ "response": final,+ "resumed_from_step": len(completed_steps),+ "steps_completed": len(all_results),+ }++ except Exception as e:+ self.state_mgr.fail_task(task_id, str(e))+ return {"success": False, "task_id": task_id, "error": str(e)}++ def _plan_steps(self, query: str, config: Dict[str, Any]) -> List[str]:+ """Ask the LLM to decompose the query into steps."""+ from finagent_core.core_agent import CoreAgent++ plan_config = {+ **config,+ "instructions": self.PLAN_PROMPT_TEMPLATE.format(query=query),+ "tools": [], # No tools needed for planning+ "markdown": False,+ }++ agent = CoreAgent(api_keys=self.api_keys)+ response = agent.run("Plan the steps.", plan_config)+ text = agent.get_response_content(response).strip()++ # Strip markdown fences+ if text.startswith("```"):+ text = text.split("```")[1]+ if text.startswith("json"):+ text = text[4:]+ text = text.strip()++ try:+ steps = json.loads(text)+ if isinstance(steps, list) and all(isinstance(s, str) for s in steps):+ return steps[:10] # Cap at 10 steps+ except Exception:+ pass++ return [query] # Fallback: single step++ def _execute_step(+ self,+ step_desc: str,+ original_query: str,+ config: Dict[str, Any],+ step_index: int,+ prior_results: List[Any],+ ) -> Dict[str, Any]:+ """Execute a single step with full tool access and prior context."""+ from finagent_core.core_agent import CoreAgent++ # Build context from prior steps+ context_parts = []+ for j, r in enumerate(prior_results):+ if isinstance(r, dict) and r.get("response"):+ context_parts.append(f"Step {j+1} result: {r['response'][:500]}")++ context = "\n".join(context_parts)+ step_prompt = f"""Original goal: {original_query}++Prior steps completed:+{context if context else "(none)"}++Current step {step_index + 1}: {step_desc}++Execute this step thoroughly using available tools."""++ agent = CoreAgent(api_keys=self.api_keys)+ response = agent.run(step_prompt, config)+ content = agent.get_response_content(response)++ return {+ "step": step_index + 1,+ "description": step_desc,+ "response": content,+ }++ def _synthesize(+ self,+ original_query: str,+ all_results: List[Dict[str, Any]],+ config: Dict[str, Any],+ ) -> str:+ """Synthesize all step results into a final coherent answer."""+ from finagent_core.core_agent import CoreAgent++ # Per-step budget: keep total synthesis prompt under 35k chars+ # (leaving room for system prompt, query, and synthesis instructions)+ MAX_SYNTHESIS_CHARS = 30_000+ per_step_budget = max(500, MAX_SYNTHESIS_CHARS // max(len(all_results), 1))++ step_summaries = []+ for i, r in enumerate(all_results):+ step_text = str(r.get("response", ""))+ if len(step_text) > per_step_budget:+ step_text = step_text[:per_step_budget] + "\n... [truncated for length]"+ step_summaries.append(+ f"**Step {r.get('step', i+1)}: {r.get('description', '')}**\n{step_text}"+ )++ steps_summary = "\n\n".join(step_summaries)++ synthesis_config = {+ **config,+ "instructions": "You are a financial analyst. Synthesize the research steps into a clear, comprehensive final answer.",+ "tools": [], # Synthesis is pure reasoning+ }++ prompt = f"""The user asked: {original_query}++Here are the research steps completed:++{steps_summary}++Synthesize all of the above into a single comprehensive, well-structured final answer."""++ agent = CoreAgent(api_keys=self.api_keys)+ response = agent.run(prompt, synthesis_config)+ return agent.get_response_content(response)+++# ─── Module-level helpers for main.py dispatch ───────────────────────────────++_state_mgr: Optional[TaskStateManager] = None+++def get_state_manager(db_path: str = _DEFAULT_DB) -> TaskStateManager:+ global _state_mgr+ if _state_mgr is None:+ _state_mgr = TaskStateManager(db_path)+ return _state_mgrdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/__init__.pynew file mode 100644index 000000000..e5a959ff3--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/__init__.py@@ -0,0 +1,8 @@+"""+finagent_core custom tools — internal Fincept tool adapters.+"""++from finagent_core.tools.edgar_tools import EdgarTools+from finagent_core.tools.terminal_toolkit import TerminalToolkit++__all__ = ["EdgarTools", "TerminalToolkit"]diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/edgar_tools.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/edgar_tools.pynew file mode 100644index 000000000..8c51d4a18--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/edgar_tools.py@@ -0,0 +1,319 @@+"""+EdgarTools — Agno-compatible toolkit wrapping the internal Fincept Edgar MCP.++Exposes SEC EDGAR data as LLM-callable tools:+ - Company search and info+ - 10-K annual reports (sections, full text, exhibits, search)+ - 10-Q quarterly reports+ - 8-K corporate events+ - Form 4 insider transactions+ - 13F institutional holdings+ - XBRL financial data++Usage in agent config:+ "tools": ["edgar"]++The LLM can then call e.g.:+ get_10k_sections(ticker="AAPL", sections="business,risk_factors")+ get_insider_transactions(ticker="TSLA")+ get_financials(ticker="NVDA")+"""++import json+import logging+import sys+from pathlib import Path+from typing import Optional++logger = logging.getLogger(__name__)++# Ensure the scripts root is on sys.path so mcp.edgar is importable+_SCRIPTS_ROOT = str(Path(__file__).parent.parent.parent.parent)+if _SCRIPTS_ROOT not in sys.path:+ sys.path.insert(0, _SCRIPTS_ROOT)+++def _call(command: str, *args) -> str:+ """+ Call execute_command from the internal Edgar MCP and return a compact+ JSON string suitable for passing back to the LLM.+ """+ try:+ from mcp.edgar import main as edgar_main+ from mcp.edgar import base as edgar_base+ # Auto-initialize identity on first call+ edgar_base.initialize_edgar()+ result = edgar_main.execute_command(command, list(str(a) for a in args))+ # Return compact JSON; cap at 8 000 chars so the LLM isn't overwhelmed+ text = json.dumps(result, default=str)+ if len(text) > 8_000:+ text = text[:8_000] + "... [truncated]"+ return text+ except ImportError:+ return json.dumps({"error": "edgartools library not installed. Run: pip install edgartools"})+ except Exception as e:+ return json.dumps({"error": str(e)})+++# ---------------------------------------------------------------------------+# Agno Toolkit+# ---------------------------------------------------------------------------++try:+ from agno.tools import Toolkit++ class EdgarTools(Toolkit):+ """+ SEC EDGAR toolkit for Fincept agents.++ Provides access to:+ - Company search and profile data+ - 10-K annual report sections+ - 10-Q quarterly report sections+ - 8-K corporate event filings+ - Form 4 insider transaction data+ - 13F institutional holdings+ - XBRL financial statements and metrics+ """++ def __init__(self, **kwargs):+ super().__init__(name="edgar", **kwargs)+ # Register all tools+ self.register(self.find_company)+ self.register(self.get_company_info)+ self.register(self.get_10k_sections)+ self.register(self.get_10k_full_text)+ self.register(self.search_10k)+ self.register(self.get_10q_sections)+ self.register(self.get_10q_full_text)+ self.register(self.get_8k_events)+ self.register(self.get_insider_transactions)+ self.register(self.get_insider_summary)+ self.register(self.get_13f_holdings)+ self.register(self.get_13f_top_holdings)+ self.register(self.get_financials)+ self.register(self.get_financial_metrics)++ # ── Company Search ────────────────────────────────────────────────++ def find_company(self, query: str) -> str:+ """+ Search for companies on SEC EDGAR by name.++ Args:+ query: Company name or partial name (e.g. "Apple", "Tesla").++ Returns:+ JSON list of matching companies with ticker, CIK, and name.+ """+ return _call("find_company", query)++ def get_company_info(self, ticker: str) -> str:+ """+ Get detailed company information from SEC EDGAR.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL", "MSFT").++ Returns:+ JSON with CIK, name, industry, SIC code, fiscal year end.+ """+ return _call("get_company", ticker)++ # ── 10-K Annual Reports ───────────────────────────────────────────++ def get_10k_sections(self, ticker: str, sections: str = "business") -> str:+ """+ Extract specific sections from a company's latest 10-K annual report.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ sections: Comma-separated section names. Valid values:+ business, risk_factors, mda (Management Discussion & Analysis),+ financials, controls, compensation, governance, all_items.+ Default: "business".++ Returns:+ JSON with the requested section texts.+ """+ section_list = [s.strip() for s in sections.split(",")]+ return _call("10k_sections", ticker, *section_list)++ def get_10k_full_text(self, ticker: str, max_length: int = 20000) -> str:+ """+ Get the full text of a company's latest 10-K filing.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ max_length: Maximum characters to return (default 20000).++ Returns:+ JSON with the 10-K full text (truncated to max_length).+ """+ return _call("10k_full_text", ticker, str(max_length))++ def search_10k(self, ticker: str, query: str, max_results: int = 10) -> str:+ """+ Search within a company's 10-K filing for specific topics.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ query: Search query (e.g. "revenue recognition", "litigation").+ max_results: Maximum number of results (default 10).++ Returns:+ JSON with matching passages and their context.+ """+ return _call("10k_search", ticker, query, str(max_results))++ # ── 10-Q Quarterly Reports ────────────────────────────────────────++ def get_10q_sections(self, ticker: str, sections: str = "part_i_item_2") -> str:+ """+ Extract specific sections from a company's latest 10-Q quarterly report.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ sections: Comma-separated section names. Valid values:+ part_i_item_1 (Financial Statements),+ part_i_item_2 (MD&A),+ part_i_item_3 (Quantitative Disclosures),+ part_i_item_4 (Controls),+ part_ii_item_1 (Legal Proceedings),+ all_items.+ Default: "part_i_item_2".++ Returns:+ JSON with the requested section texts.+ """+ section_list = [s.strip() for s in sections.split(",")]+ return _call("10q_sections", ticker, *section_list)++ def get_10q_full_text(self, ticker: str, max_length: int = 15000) -> str:+ """+ Get the full text of a company's latest 10-Q filing.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ max_length: Maximum characters to return (default 15000).++ Returns:+ JSON with the 10-Q full text.+ """+ return _call("10q_full_text", ticker, str(max_length))++ # ── 8-K Corporate Events ──────────────────────────────────────────++ def get_8k_events(self, ticker: str, limit: int = 20) -> str:+ """+ Get recent 8-K corporate event filings for a company.+ 8-K filings report material events: earnings releases, M&A,+ leadership changes, bankruptcy, etc.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ limit: Number of recent events to retrieve (default 20).++ Returns:+ JSON list of 8-K events with date, item type, and description.+ """+ return _call("8k_events", ticker, str(limit))++ # ── Insider Transactions (Form 4) ─────────────────────────────────++ def get_insider_transactions(self, ticker: str, limit: int = 25) -> str:+ """+ Get recent insider transactions (Form 4 filings) for a company.+ Shows purchases and sales by executives, directors, and major shareholders.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ limit: Number of recent transactions to retrieve (default 25).++ Returns:+ JSON list of insider transactions with date, insider name,+ transaction type (buy/sell), shares, and price.+ """+ return _call("insider_transactions", ticker, str(limit))++ def get_insider_summary(self, ticker: str, limit: int = 50) -> str:+ """+ Get a summary of insider buying vs selling activity for a company.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ limit: Number of transactions to summarize (default 50).++ Returns:+ JSON summary with net buy/sell counts and total value.+ """+ return _call("insider_summary", ticker, str(limit))++ # ── 13F Institutional Holdings ────────────────────────────────────++ def get_13f_holdings(self, ticker: str, quarters: int = 2) -> str:+ """+ Get 13F institutional holdings data for a company across recent quarters.+ Shows which institutional investors (hedge funds, mutual funds) hold the stock.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ quarters: Number of recent quarters to retrieve (default 2).++ Returns:+ JSON with institutional holdings per quarter including shares+ and market value.+ """+ return _call("13f_holdings", ticker, str(quarters))++ def get_13f_top_holdings(self, ticker: str, top_n: int = 20) -> str:+ """+ Get the top institutional holders of a company's stock.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ top_n: Number of top holders to return (default 20).++ Returns:+ JSON list of top institutional holders with shares and percentage.+ """+ return _call("13f_top_holdings", ticker, str(top_n))++ # ── XBRL Financials ───────────────────────────────────────────────++ def get_financials(self, ticker: str, periods: int = 4, annual: bool = True) -> str:+ """+ Get XBRL financial statements (Balance Sheet, Income Statement,+ Cash Flow) for a company.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").+ periods: Number of reporting periods to retrieve (default 4).+ annual: True for annual (10-K) data, False for quarterly (10-Q).++ Returns:+ JSON with Balance Sheet, Income Statement, and Cash Flow data.+ """+ return _call("get_financials", ticker, str(periods), str(annual).lower())++ def get_financial_metrics(self, ticker: str) -> str:+ """+ Get key financial metrics for a company (revenue, net income, EPS,+ profit margin, etc.) from SEC EDGAR XBRL data.++ Args:+ ticker: Stock ticker symbol (e.g. "AAPL").++ Returns:+ JSON with key financial metrics and their values.+ """+ return _call("get_financial_metrics", ticker)++except ImportError:+ # Agno not available — define a stub so import doesn't crash+ logger.warning("agno not installed; EdgarTools stub created")++ class EdgarTools: # type: ignore+ """Stub when agno is not installed."""+ def __init__(self, **kwargs):+ passdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/terminal_toolkit.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/terminal_toolkit.pynew file mode 100644index 000000000..74551a540--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tools/terminal_toolkit.py@@ -0,0 +1,197 @@+"""+TerminalToolkit - Agno Toolkit that proxies calls to Fincept Terminal internal MCP tools.++When finagent_core runs as a Python subprocess, it cannot call Tauri IPC directly.+This toolkit bridges that gap via the local HTTP bridge (mcp_bridge.rs):++ Python agent → POST http://127.0.0.1:{port}/tool → Rust bridge+ → Tauri event → TypeScript mcpToolService.executeToolDirect()+ → register_mcp_tool_result → Rust bridge → HTTP response → Python++Usage:+ toolkit = TerminalToolkit(+ endpoint="http://127.0.0.1:12345",+ tool_definitions=[+ {"name": "get_quote", "description": "...", "inputSchema": {...}},+ ...+ ]+ )+ agent = Agent(tools=[toolkit], ...)+"""++import json+import uuid+import logging+import urllib.request+import urllib.error+from typing import Any, Dict, List, Optional++logger = logging.getLogger(__name__)+++class TerminalToolkit:+ """+ Agno-compatible toolkit that wraps Fincept Terminal's internal TypeScript MCP tools.++ Each tool definition becomes a Python function registered with Agno so the LLM+ can call it. Calls are forwarded to the local HTTP bridge which routes them to+ the TypeScript TerminalMCPProvider.+ """++ def __init__(+ self,+ endpoint: str,+ tool_definitions: List[Dict[str, Any]],+ timeout_seconds: int = 30,+ **kwargs,+ ):+ self.endpoint = endpoint.rstrip("/")+ self.tool_definitions = tool_definitions+ self.timeout_seconds = timeout_seconds+ self.functions: List[Any] = []++ # Build Agno-compatible function wrappers+ self._build_functions()++ logger.info(+ f"TerminalToolkit: {len(self.functions)} tools registered, endpoint={self.endpoint}"+ )++ # ------------------------------------------------------------------+ # Agno Toolkit interface+ # ------------------------------------------------------------------++ def get_tools(self) -> List[Any]:+ """Returns list of Agno Function objects for use by the Agent."""+ return self.functions++ # ------------------------------------------------------------------+ # Internal: build one Python function per tool definition+ # ------------------------------------------------------------------++ def _build_functions(self) -> None:+ """+ Dynamically create a Python callable for each tool definition and wrap it+ as an Agno Function so the agent can discover and call it.+ """+ try:+ from agno.tools import Function+ except ImportError:+ logger.warning("agno.tools.Function not available — using simple callables")+ Function = None++ for tool_def in self.tool_definitions:+ name: str = tool_def.get("name", "")+ description: str = tool_def.get("description", f"Terminal tool: {name}")+ input_schema: Dict = tool_def.get("inputSchema", {"type": "object", "properties": {}})++ if not name:+ continue++ # Create a closure that captures `name`+ fn = self._make_tool_fn(name, description, input_schema)++ if Function is not None:+ try:+ # Register as Agno Function with proper schema+ agno_fn = Function(+ name=name,+ description=description,+ parameters=input_schema,+ entrypoint=fn,+ )+ self.functions.append(agno_fn)+ continue+ except Exception as e:+ logger.debug(f"Agno Function wrapping failed for {name}: {e}, using raw callable")++ # Fallback: raw callable (Agno can sometimes infer tools from callables)+ self.functions.append(fn)++ def _make_tool_fn(+ self, name: str, description: str, input_schema: Dict+ ):+ """Returns a callable that, when called with kwargs, forwards to the HTTP bridge."""+ toolkit_self = self++ def tool_fn(**kwargs) -> str:+ return toolkit_self._call_tool(name, kwargs)++ # Set function metadata so Agno can use it+ tool_fn.__name__ = name+ tool_fn.__doc__ = description++ # Attach schema for Agno introspection+ tool_fn.__annotations__ = {}+ tool_fn._input_schema = input_schema++ return tool_fn++ # ------------------------------------------------------------------+ # HTTP bridge call+ # ------------------------------------------------------------------++ def _call_tool(self, tool_name: str, args: Dict[str, Any]) -> str:+ """+ POST { id, tool, args } to the Rust HTTP bridge.+ Returns the tool result as a JSON string for the LLM.+ """+ call_id = str(uuid.uuid4())+ payload = {+ "id": call_id,+ "tool": tool_name,+ "args": args,+ }++ try:+ data = json.dumps(payload).encode("utf-8")+ req = urllib.request.Request(+ f"{self.endpoint}/tool",+ data=data,+ headers={+ "Content-Type": "application/json",+ "Content-Length": str(len(data)),+ },+ method="POST",+ )++ with urllib.request.urlopen(req, timeout=self.timeout_seconds) as resp:+ response_body = resp.read().decode("utf-8")++ result = json.loads(response_body)++ if result.get("success") is False or result.get("error"):+ error_msg = result.get("error", "Tool execution failed")+ logger.warning(f"Terminal tool '{tool_name}' returned error: {error_msg}")+ return json.dumps({"error": error_msg})++ data_val = result.get("data")+ if data_val is None:+ data_val = result.get("message", "Tool executed successfully")++ return json.dumps(data_val) if not isinstance(data_val, str) else data_val++ except urllib.error.URLError as e:+ logger.error(f"Terminal tool '{tool_name}' HTTP error: {e}")+ return json.dumps({"error": f"Bridge unreachable: {e}"})+ except json.JSONDecodeError as e:+ logger.error(f"Terminal tool '{tool_name}' JSON decode error: {e}")+ return json.dumps({"error": "Invalid JSON response from bridge"})+ except Exception as e:+ logger.error(f"Terminal tool '{tool_name}' unexpected error: {e}")+ return json.dumps({"error": str(e)})++ # ------------------------------------------------------------------+ # Agno Toolkit interface (alternative registration style)+ # ------------------------------------------------------------------++ def register_with_agent(self, agent) -> None:+ """+ Alternative: directly register all tool functions into an Agno agent's tool list.+ Called if the standard get_tools() approach doesn't work.+ """+ if hasattr(agent, "tools") and isinstance(agent.tools, list):+ agent.tools.extend(self.functions)+ elif hasattr(agent, "register"):+ for fn in self.functions:+ agent.register(fn)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/arq_capital_hedge_fund_agent/arq_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/arq_capital_hedge_fund_agent/arq_agent.pydeleted file mode 100644index 14e36f777..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/arq_capital_hedge_fund_agent/arq_agent.py+++ /dev/null@@ -1,915 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio, P/E, P/B, ROIC, ROA-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares, Total Assets, Current Assets, Current Liabilities-# - Market Cap-# - Factor scores: Value, Momentum, Quality, Low Volatility, Profitability-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-# - factor_combination_weights: Value=35%, Momentum=35%, Quality=30%-# - academic_validation_threshold: 95% confidence level-"""---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/hedgeFundAgents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.pydeleted file mode 100644index fabdef2b6..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py+++ /dev/null@@ -1,528 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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/hedgeFundAgents/citadel_hedge_fund_agent/citadel_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/citadel_hedge_fund_agent/citadel_agent.pydeleted file mode 100644index 020b4036e..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/citadel_hedge_fund_agent/citadel_agent.py+++ /dev/null@@ -1,829 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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:- # CAGR formula: (End Value / Start Value)^(1 / number_of_periods) - 1- # number_of_periods = len(revenues) - 1 (not len(revenues))- # revenues[0] is most recent, revenues[-1] is oldest- num_periods = len(revenues) - 1- if revenues[-1] > 0: # Prevent division by zero- revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / num_periods) - 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 and revenues[-1] > 0:- # CAGR: number of periods = len - 1- num_periods = len(revenues) - 1- growth = (revenues[0] / revenues[-1]) ** (1 / num_periods) - 1- factors["growth_factor"] = min(max(growth / 0.15, 0.0), 1.0) # Normalize by 15%, clamp 0-1-- 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.-- High pricing power = stable margins over time (companies can maintain margins- regardless of input cost fluctuations or competitive pressure).-- Returns 0-1 where 1 = very stable margins (strong pricing power)- """- margins = []- for item in financial_line_items:- if item.operating_margin is not None:- margins.append(item.operating_margin)-- if len(margins) >= 3:- max_margin = max(margins)- min_margin = min(margins)-- # Prevent division by zero when max_margin is 0 or negative- if max_margin > 0:- margin_stability = 1 - ((max_margin - min_margin) / max_margin)- return max(min(margin_stability, 1.0), 0.0)- elif max_margin == 0 and min_margin == 0:- # All zero margins - no pricing power signal- return 0.3- else:- # Negative margins indicate no pricing power- return 0.1-- 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 using proper percentile-based approach.-- Returns a score from 0 to 1 where:- - 0 = Low tail risk (worst case is close to average)- - 1 = High tail risk (worst case is much worse than average)- """- earnings = [item.net_income for item in financial_line_items if item.net_income is not None]-- if not earnings or len(earnings) < 2:- return 0.5 # Default for insufficient data-- sorted_earnings = sorted(earnings)- avg_earnings = sum(earnings) / len(earnings)-- # Use proper percentile calculation- # For small samples (typical 5-10 years), use bottom 10-20% or minimum- if len(earnings) >= 10:- # Use 10th percentile for larger samples- percentile_index = max(0, int(len(earnings) * 0.10))- worst_performance = sorted_earnings[percentile_index]- elif len(earnings) >= 5:- # Use 20th percentile for medium samples- percentile_index = max(0, int(len(earnings) * 0.20))- worst_performance = sorted_earnings[percentile_index]- else:- # For very small samples, use minimum- worst_performance = sorted_earnings[0]-- # Calculate tail risk score- if avg_earnings > 0:- # Ratio of worst to average (negative worst = higher risk)- if worst_performance < 0:- # Negative earnings in worst case = high tail risk- tail_risk = min(abs(worst_performance) / avg_earnings, 1.0)- else:- # Positive but lower than average- tail_risk = max(0, 1 - (worst_performance / avg_earnings)) * 0.5- elif avg_earnings < 0:- # Average is negative - company is unprofitable on average- tail_risk = 0.8 # High risk- else:- tail_risk = 0.5 # Neutral-- return min(max(tail_risk, 0.0), 1.0) # Clamp to 0-1---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/hedgeFundAgents/de_shaw_hedge_fund_agent/de_shaw_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/de_shaw_hedge_fund_agent/de_shaw_agent.pydeleted file mode 100644index b4700b8e6..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/de_shaw_hedge_fund_agent/de_shaw_agent.py+++ /dev/null@@ -1,930 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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/hedgeFundAgents/elliott_management_hedge_fund_agent/elliott_management_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/elliott_management_hedge_fund_agent/elliott_management_agent.pydeleted file mode 100644index 894080209..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/elliott_management_hedge_fund_agent/elliott_management_agent.py+++ /dev/null@@ -1,842 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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/hedgeFundAgents/fincept_hedge_fund/main.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/fincept_hedge_fund/main.pydeleted file mode 100644index 0d9b2d07d..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/fincept_hedge_fund/main.py+++ /dev/null@@ -1,800 +0,0 @@-# -*- coding: utf-8 -*--# main.py - AI Hedge Fund Orchestrator and Execution Engine--"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - Agent reports from all hedge fund agents-# - Market data feeds (real-time and historical)-# - Portfolio current positions and allocations-# - Risk management parameters and limits-# - Trading signals and market regime data-#-# OUTPUT:-# - Aggregated trading signals with conviction scores-# - Portfolio recommendations with asset allocations-# - Risk-adjusted position sizes using Kelly Criterion-# - Execution results with trading costs and slippage-# - Performance metrics and portfolio analytics-#-# PARAMETERS:-# - max_position_size: Maximum single position limit (default 10%)-# - max_sector_exposure: Maximum sector allocation limit (default 25%)-# - var_limit: Value-at-Risk limit (default 5%)-# - update_frequency: Analysis cycle frequency (default 60 seconds)-# - agent_weights: Weight distribution for different agents-"""--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/hedgeFundAgents/pershing_square_hedge_fund_agent/pershing_square_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/pershing_square_hedge_fund_agent/pershing_square_agent.pydeleted file mode 100644index 7138bf2be..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/pershing_square_hedge_fund_agent/pershing_square_agent.py+++ /dev/null@@ -1,1002 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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/hedgeFundAgents/renaissance_technologies_hedge_fund_agent/rentech_cli.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/renaissance_technologies_hedge_fund_agent/rentech_cli.pydeleted file mode 100644index 40273d99d..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/renaissance_technologies_hedge_fund_agent/rentech_cli.py+++ /dev/null@@ -1,750 +0,0 @@-#!/usr/bin/env python3-"""-Renaissance Technologies Multi-Agent System CLI-================================================-Command-line interface for the RenTech multi-agent system.-Called by Tauri/Rust via worker pool or subprocess.--Usage:- python rentech_cli.py <command> [args...]--Commands:- # Agent operations- create_agent <json_config> - Create and return agent info- run_agent <json_config> - Run agent with task- list_agent_presets - List available agent presets-- # Team operations- create_team <json_config> - Create and return team info- run_team <json_config> - Run team with task- list_team_presets - List available team presets-- # IC Deliberation- run_ic_deliberation <json_data> - Run full IC deliberation on signal-- # System operations- analyze_signal <json_data> - Full signal analysis pipeline- get_config_schema - Get JSON schema for configurations- health_check - Check system health--Example:- python rentech_cli.py run_agent '{- "config": {"name": "Analyst", "model": {"temperature": 0.3}},- "task": "Analyze AAPL momentum signal"- }'-"""--import sys-import json-import os-import asyncio-from typing import Dict, Any, Optional-from datetime import datetime--# Add script directory to path-script_dir = os.path.dirname(os.path.abspath(__file__)) if '__file__' in dir() else os.getcwd()-if script_dir not in sys.path:- sys.path.insert(0, script_dir)--# Parent directory for imports-parent_dir = os.path.dirname(script_dir)-if parent_dir not in sys.path:- sys.path.insert(0, parent_dir)---# =============================================================================-# RESPONSE HELPERS-# =============================================================================--def success_response(data: Any, message: str = "Success") -> str:- """Create success response JSON"""- return json.dumps({- "success": True,- "message": message,- "data": data,- "timestamp": datetime.utcnow().isoformat(),- }, indent=2, default=str)---def error_response(error: str, traceback_str: Optional[str] = None) -> str:- """Create error response JSON"""- return json.dumps({- "success": False,- "error": error,- "traceback": traceback_str,- "timestamp": datetime.utcnow().isoformat(),- }, indent=2)---# =============================================================================-# MODEL FACTORY-# =============================================================================--def create_model_from_settings(model_settings: Dict[str, Any]):- """- Create Agno model from ModelSettings dict.-- Uses the new dynamic model factory that reads from frontend SQLite database- and supports all Agno providers (40+).-- Args:- model_settings: Dictionary with model configuration-- Returns:- Agno model instance- """- from .utils.model_factory import create_model_from_config-- # Convert model_settings to config dict format- config_dict = {- "provider": model_settings.get("provider", "openai"),- "model_id": model_settings.get("model_id", "gpt-4o"),- "api_key": model_settings.get("api_key"),- "base_url": model_settings.get("base_url"),- "temperature": model_settings.get("temperature", 0.7),- "max_tokens": model_settings.get("max_tokens", 4096)- }-- # Use factory to create model (will read from frontend DB if no override)- return create_model_from_config(config_dict)---# =============================================================================-# AGENT OPERATIONS-# =============================================================================--def create_agent(json_str: str) -> str:- """- Create an agent from JSON configuration.-- Input JSON:- {- "config": {AgentConfig},- "task": "optional task to run immediately"- }- """- try:- from agno.agent import Agent- from .schemas import AgentConfig-- data = json.loads(json_str)- config_data = data.get("config", data)-- # Parse config- config = AgentConfig.from_dict(config_data)-- # Create model- model = create_model_from_settings(config.model.to_dict())-- # Get Agno kwargs- kwargs = config.to_agno_kwargs()- kwargs["model"] = model-- # Create agent- agent = Agent(**kwargs)-- # If task provided, run it- task = data.get("task")- if task:- response = agent.run(task)- content = response.content if hasattr(response, 'content') else str(response)-- return success_response({- "agent_name": config.name,- "task": task,- "response": content,- }, "Agent executed successfully")- else:- return success_response({- "agent_name": config.name,- "agent_id": config.id,- "role": config.role,- "status": "created",- }, "Agent created successfully")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---def run_agent(json_str: str) -> str:- """- Run an agent with a task.-- Input JSON:- {- "config": {AgentConfig},- "task": "The task to run",- "context": {"optional": "context data"}- }- """- try:- from agno.agent import Agent- from .schemas import AgentConfig-- data = json.loads(json_str)-- if "task" not in data:- return error_response("Missing 'task' in input")-- config_data = data.get("config", {})- task = data["task"]- context = data.get("context", {})-- # Parse config- config = AgentConfig.from_dict(config_data)-- # Create model- model = create_model_from_settings(config.model.to_dict())-- # Get Agno kwargs- kwargs = config.to_agno_kwargs()- kwargs["model"] = model-- # Create and run agent- agent = Agent(**kwargs)-- # Build task with context- if context:- context_str = "\n".join([f"- {k}: {v}" for k, v in context.items()])- full_task = f"{task}\n\nContext:\n{context_str}"- else:- full_task = task-- response = agent.run(full_task)- content = response.content if hasattr(response, 'content') else str(response)-- return success_response({- "agent_name": config.name or "Agent",- "task": task,- "response": content,- }, "Agent task completed")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---def list_agent_presets() -> str:- """List available agent preset configurations"""- try:- from .schemas import (- get_research_agent_config,- get_trading_agent_config,- get_risk_agent_config,- )-- presets = {- "research": get_research_agent_config().to_dict(),- "trading": get_trading_agent_config().to_dict(),- "risk": get_risk_agent_config().to_dict(),- }-- return success_response({- "presets": list(presets.keys()),- "configs": presets,- }, "Agent presets retrieved")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---# =============================================================================-# TEAM OPERATIONS-# =============================================================================--def create_team(json_str: str) -> str:- """- Create a team from JSON configuration.-- Input JSON:- {- "config": {TeamConfig},- "task": "optional task to run immediately"- }- """- try:- from agno.agent import Agent- from agno.team import Team- from .schemas import TeamConfig, AgentConfig-- data = json.loads(json_str)- config_data = data.get("config", data)-- # Parse config- config = TeamConfig.from_dict(config_data)-- # Create model for team- team_model = create_model_from_settings(config.model.to_dict())-- # Create member agents- members = []- for member_config in config.member_configs:- member_model = create_model_from_settings(member_config.model.to_dict())- member_kwargs = member_config.to_agno_kwargs()- member_kwargs["model"] = member_model- members.append(Agent(**member_kwargs))-- # Get Team kwargs- team_kwargs = config.to_agno_kwargs()- team_kwargs["model"] = team_model- team_kwargs["members"] = members-- # Create team- team = Team(**team_kwargs)-- # If task provided, run it- task = data.get("task")- if task:- response = team.run(task)- content = response.content if hasattr(response, 'content') else str(response)-- return success_response({- "team_name": config.name,- "member_count": len(members),- "task": task,- "response": content,- }, "Team executed successfully")- else:- return success_response({- "team_name": config.name,- "team_id": config.id,- "member_count": len(members),- "members": [m.name for m in members],- "status": "created",- }, "Team created successfully")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---def run_team(json_str: str) -> str:- """- Run a team with a task.-- Input JSON:- {- "config": {TeamConfig},- "task": "The task to run",- "context": {"optional": "context data"}- }- """- try:- from agno.agent import Agent- from agno.team import Team- from .schemas import TeamConfig-- data = json.loads(json_str)-- if "task" not in data:- return error_response("Missing 'task' in input")-- config_data = data.get("config", {})- task = data["task"]- context = data.get("context", {})-- # Parse config- config = TeamConfig.from_dict(config_data)-- # Create model for team- team_model = create_model_from_settings(config.model.to_dict())-- # Create member agents- members = []- for member_config in config.member_configs:- member_model = create_model_from_settings(member_config.model.to_dict())- member_kwargs = member_config.to_agno_kwargs()- member_kwargs["model"] = member_model- members.append(Agent(**member_kwargs))-- # Get Team kwargs- team_kwargs = config.to_agno_kwargs()- team_kwargs["model"] = team_model- team_kwargs["members"] = members-- # Create team- team = Team(**team_kwargs)-- # Build task with context- if context:- context_str = "\n".join([f"- {k}: {v}" for k, v in context.items()])- full_task = f"{task}\n\nContext:\n{context_str}"- else:- full_task = task-- response = team.run(full_task)- content = response.content if hasattr(response, 'content') else str(response)-- return success_response({- "team_name": config.name or "Team",- "member_count": len(members),- "task": task,- "response": content,- }, "Team task completed")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---def list_team_presets() -> str:- """List available team preset configurations"""- try:- from .schemas import (- get_research_team_config,- get_trading_team_config,- get_risk_team_config,- get_investment_committee_config,- )-- presets = {- "research": get_research_team_config().to_dict(),- "trading": get_trading_team_config().to_dict(),- "risk": get_risk_team_config().to_dict(),- "investment_committee": get_investment_committee_config().to_dict(),- }-- return success_response({- "presets": list(presets.keys()),- "configs": presets,- }, "Team presets retrieved")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---# =============================================================================-# IC DELIBERATION-# =============================================================================--def run_ic_deliberation(json_str: str) -> str:- """- Run full Investment Committee deliberation on a signal.-- Input JSON:- {- "signal": {- "ticker": "AAPL",- "direction": "long",- "signal_type": "momentum",- "p_value": 0.008,- "confidence": 0.58,- "expected_return_bps": 85- },- "risk_assessment": {- "risk_level": "medium",- "var_utilization_pct": 45- },- "sizing_recommendation": {- "final_size_pct": 1.5- },- "market_context": {- "vix": 16.5,- "regime": "bullish"- }- }- """- try:- from .reasoning.ic_deliberation import get_ic_deliberator-- data = json.loads(json_str)-- signal = data.get("signal", {})- signal_evaluation = data.get("signal_evaluation", {- "statistical_quality": "good",- "overall_score": 70,- })- risk_assessment = data.get("risk_assessment", {- "risk_level": "medium",- })- sizing_recommendation = data.get("sizing_recommendation", {- "final_size_pct": 1.0,- })- market_context = data.get("market_context", {- "vix": 20,- "regime": "neutral",- })- historical_decisions = data.get("historical_decisions", [])-- deliberator = get_ic_deliberator()-- # Run deliberation- result = asyncio.run(deliberator.deliberate(- signal=signal,- signal_evaluation=signal_evaluation,- risk_assessment=risk_assessment,- sizing_recommendation=sizing_recommendation,- market_context=market_context,- historical_decisions=historical_decisions,- ))-- # Get model config for response- from .config import get_config- cfg = get_config()-- return success_response({- "deliberation_id": result.deliberation_id,- "subject": result.subject,- "decision": result.decision,- "decision_rationale": result.decision_rationale,- "conditions": result.conditions,- "approved_size_pct": result.approved_size_pct,- "confidence": result.confidence,- "vote_summary": result.vote_summary,- "member_opinions": [- {- "member": op.member_role,- "vote": op.vote.value,- "rationale": op.rationale,- "confidence": op.confidence,- }- for op in result.member_opinions- ],- "pros": result.pros,- "cons": result.cons,- "reasoning_summary": result.reasoning_chain_summary,- "llm_config": {- "provider": cfg.models.provider.value,- "model_id": cfg.models.model_id,- "temperature": cfg.models.temperature,- },- }, f"IC Decision: {result.decision}")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---# =============================================================================-# SIGNAL ANALYSIS-# =============================================================================--def analyze_signal(json_str: str) -> str:- """- Run full signal analysis pipeline.-- Input JSON:- {- "ticker": "AAPL",- "signal_type": "momentum",- "direction": "long",- "trade_value": 1000000,- "include_deliberation": true- }- """- try:- from .main import RenaissanceTechnologiesSystem, AnalysisConfig-- data = json.loads(json_str)-- ticker = data.get("ticker", "AAPL")- trade_value = data.get("trade_value", 1_000_000)- period = data.get("period", "1y")- include_deliberation = data.get("include_deliberation", False)-- # Create system and config- system = RenaissanceTechnologiesSystem()- config = AnalysisConfig(- trade_value=trade_value,- period=period,- )-- # Run analysis- decision = system.analyze(ticker, config)-- result = {- "ticker": ticker,- "signal": decision.signal.value,- "confidence": decision.confidence,- "statistical_edge": decision.statistical_edge,- "signal_score": decision.signal_score,- "risk_score": decision.risk_score,- "execution_score": decision.execution_score,- "arbitrage_score": decision.arbitrage_score,- "position_sizing": {- "recommended_size_pct": decision.position_sizing.recommended_size_pct,- "kelly_fraction": decision.position_sizing.kelly_fraction,- "leverage": decision.position_sizing.leverage_recommendation,- },- "signal_strength": decision.signal_strength,- "key_factors": decision.key_factors,- "risks": decision.risks,- "reasoning": decision.reasoning,- }-- # Include IC deliberation if requested- if include_deliberation:- # Calculate p-value from statistical significance- p_value = 1 - (decision.signal_score / 10.0) # Convert 0-10 scale to p-value- p_value = max(0.001, min(0.5, p_value)) # Clamp between 0.001 and 0.5-- delib_result = run_ic_deliberation(json.dumps({- "signal": {- "ticker": ticker,- "direction": decision.signal.value,- "signal_type": data.get("signal_type", "combined"),- "p_value": p_value, # Use calculated p-value- "confidence": decision.confidence / 100,- "expected_return_bps": decision.statistical_edge * 10000,- "average_daily_volume": 10_000_000, # TODO: Fetch from yfinance/market data API- },- "signal_evaluation": {- "statistical_quality": "good" if p_value < 0.02 else "moderate" if p_value < 0.05 else "weak",- "overall_score": decision.signal_score * 10, # Convert to 0-100 scale- },- "risk_assessment": {- "risk_level": "high" if decision.risk_score < 4 else "medium" if decision.risk_score < 7 else "low",- "var_utilization_pct": 50.0, # TODO: Calculate from portfolio VaR- "risk_flags": decision.risks,- "sector_concentrations": {}, # TODO: Calculate from portfolio holdings- },- "sizing_recommendation": {- "final_size_pct": decision.position_sizing.recommended_size_pct,- "final_notional": trade_value,- },- "market_context": {- "vix": 20.0, # TODO: Fetch real-time VIX from market data- "regime": "bullish" if decision.signal.value == "long" else "bearish" if decision.signal.value == "short" else "neutral",- },- }))- result["ic_deliberation"] = json.loads(delib_result).get("data", {})-- return success_response(result, f"Analysis complete: {decision.signal.value.upper()}")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---# =============================================================================-# SYSTEM OPERATIONS-# =============================================================================--def get_config_schema() -> str:- """Get JSON schemas for all configurations"""- try:- from .schemas import get_agent_config_schema, get_team_config_schema-- return success_response({- "agent_schema": get_agent_config_schema(),- "team_schema": get_team_config_schema(),- }, "Schemas retrieved")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---def health_check() -> str:- """Check system health and available components"""- try:- status = {- "system": "operational",- "components": {},- }-- # Check Agno- try:- from agno.agent import Agent- from agno.team import Team- status["components"]["agno"] = "ok"- except ImportError as e:- status["components"]["agno"] = f"error: {e}"-- # Check model- try:- from .config import get_config- config = get_config()- status["components"]["config"] = "ok"- status["model"] = {- "provider": config.models.provider.value,- "model_id": config.models.model_id,- }- except Exception as e:- status["components"]["config"] = f"error: {e}"-- # Check reasoning- try:- from .reasoning import get_reasoning_engine- status["components"]["reasoning"] = "ok"- except Exception as e:- status["components"]["reasoning"] = f"error: {e}"-- # Check guardrails- try:- from .guardrails import get_guardrail_registry- status["components"]["guardrails"] = "ok"- except Exception as e:- status["components"]["guardrails"] = f"error: {e}"-- return success_response(status, "Health check complete")-- except Exception as e:- import traceback- return error_response(str(e), traceback.format_exc())---# =============================================================================-# MAIN CLI-# =============================================================================--COMMANDS = {- # Agent operations- "create_agent": create_agent,- "run_agent": run_agent,- "list_agent_presets": list_agent_presets,-- # Team operations- "create_team": create_team,- "run_team": run_team,- "list_team_presets": list_team_presets,-- # IC Deliberation- "run_ic_deliberation": run_ic_deliberation,-- # Signal analysis- "analyze_signal": analyze_signal,- "analyze": analyze_signal, # Alias for Tauri compatibility-- # System- "get_config_schema": get_config_schema,- "health_check": health_check,-}---def main(args: list) -> str:- """Main entry point for script execution"""- if len(args) < 1:- return json.dumps({- "success": False,- "error": "Usage: <command> [json_data]",- "commands": list(COMMANDS.keys()),- }, indent=2)-- command = args[0]- json_data = args[1] if len(args) > 1 else "{}"-- if command not in COMMANDS:- return json.dumps({- "success": False,- "error": f"Unknown command: {command}",- "available_commands": list(COMMANDS.keys()),- }, indent=2)-- handler = COMMANDS[command]-- # Commands that don't need JSON input- no_input_commands = ["list_agent_presets", "list_team_presets", "get_config_schema", "health_check"]-- if command in no_input_commands:- return handler()- else:- return handler(json_data)---if __name__ == "__main__":- result = main(sys.argv[1:])- print(result)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/two_sigma_hedge_fund_agent/two_sigma_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/two_sigma_hedge_fund_agent/two_sigma_agent.pydeleted file mode 100644index 9123ecd30..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/hedgeFundAgents/two_sigma_hedge_fund_agent/two_sigma_agent.py+++ /dev/null@@ -1,828 +0,0 @@-"""-===== DATA SOURCES REQUIRED =====-# INPUT:-# - ticker symbols (array)-# - end_date (string)-# - FINANCIAL_DATASETS_API_KEY-#-# OUTPUT:-# - Financial metrics: ROE, D/E, Current Ratio-# - Financial line items: Revenue, Net Income, FCF, Debt, Equity, Retained Earnings, Operating Margin, R&D, Shares-# - Market Cap-#-# PARAMETERS:-# - period="annual"-# - limit=10 years-"""--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 filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/polymarket.py b/fincept-terminal-desktop/src-tauri/resources/scripts/polymarket.pynew file mode 100644index 000000000..c4c2996f4--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/polymarket.py@@ -0,0 +1,83 @@+#!/usr/bin/env python3+"""+Prediction markets data fetcher+Uses Manifold Markets API (globally accessible, no auth required)+as a fallback since Polymarket is geo-restricted in some regions.+"""++import sys+import json++try:+ import requests+except ImportError:+ print(json.dumps({"success": False, "error": "requests not available", "data": []}))+ sys.exit(1)++MANIFOLD_API = "https://api.manifold.markets/v0"+++def get_markets(limit=10):+ """Fetch top active markets from Manifold Markets API"""+ try:+ url = f"{MANIFOLD_API}/markets"+ params = {+ "limit": limit,+ "sort": "last-bet-time",+ "order": "desc",+ }+ headers = {+ "Accept": "application/json",+ "User-Agent": "FinceptTerminal/3.3.1",+ }+ r = requests.get(url, params=params, headers=headers, timeout=15)+ r.raise_for_status()+ raw = r.json()++ # Normalize Manifold fields to match PolymarketMarket shape expected by frontend+ markets = []+ for m in raw:+ if m.get("outcomeType") != "BINARY":+ continue+ prob = float(m.get("probability", 0))+ yes_price = str(round(prob, 4))+ no_price = str(round(1 - prob, 4))+ volume = str(round(float(m.get("volume", 0)), 0))+ markets.append({+ "id": m.get("id", ""),+ "question": m.get("question", ""),+ "outcomePrices": [yes_price, no_price],+ "volume": volume,+ "active": not m.get("isResolved", False),+ "closed": m.get("isResolved", False),+ "url": m.get("url", ""),+ })+ if len(markets) >= limit:+ break++ return {"success": True, "data": markets, "count": len(markets)}+ except requests.exceptions.Timeout:+ return {"success": False, "error": "Request timed out", "data": []}+ except requests.exceptions.ConnectionError as e:+ return {"success": False, "error": f"Connection failed: {str(e)}", "data": []}+ except Exception as e:+ return {"success": False, "error": str(e), "data": []}+++def main():+ if len(sys.argv) < 2:+ print(json.dumps({"success": False, "error": "No command specified", "data": []}))+ sys.exit(1)++ cmd = sys.argv[1]+ if cmd == "get_markets":+ limit = int(sys.argv[2]) if len(sys.argv) > 2 else 10+ result = get_markets(limit)+ else:+ result = {"success": False, "error": f"Unknown command: {cmd}", "data": []}++ print(json.dumps(result, default=str))+++if __name__ == "__main__":+ main()diff --git a/fincept-terminal-desktop/src-tauri/src/commands/agents.rs b/fincept-terminal-desktop/src-tauri/src/commands/agents.rsindex 0959c9372..7c9d9a43f 100644--- a/fincept-terminal-desktop/src-tauri/src/commands/agents.rs+++ b/fincept-terminal-desktop/src-tauri/src/commands/agents.rs@@ -87,9 +87,27 @@ pub async fn execute_core_agent(/// This bypasses the worker pool for reliability on Windowsasync fn execute_core_agent_with_timeout(app: tauri::AppHandle,- payload: serde_json::Value,+ mut payload: serde_json::Value,timeout_secs: u64,) -> Result<String, String> {+ // Inject terminal MCP bridge endpoint so Python can call TypeScript tools+ let bridge_port = crate::mcp_bridge::get_or_start_bridge(app.clone());+ if let Some(config) = payload.get_mut("config").and_then(|c| c.as_object_mut()) {+ config.insert(+ "terminal_mcp_endpoint".to_string(),+ serde_json::Value::String(format!("http://127.0.0.1:{}", bridge_port)),+ );+ } else if payload.is_object() {+ // No config key yet — create it+ let map = payload.as_object_mut().unwrap();+ let mut config = serde_json::Map::new();+ config.insert(+ "terminal_mcp_endpoint".to_string(),+ serde_json::Value::String(format!("http://127.0.0.1:{}", bridge_port)),+ );+ map.insert("config".to_string(), serde_json::Value::Object(config));+ }+let payload_str = serde_json::to_string(&payload).map_err(|e| format!("Failed to serialize payload: {}", e))?;@@ -117,18 +135,17 @@ async fn execute_core_agent_with_timeout(eprintln!("[AgentCmd] Payload preview: {}", payload_preview);let app_clone = app.clone();- let args: Vec<String> = vec![payload_str.clone()];eprintln!("[AgentCmd] Starting Python execution with timeout={}s...", timeout_secs);let start_time = std::time::Instant::now();- // Execute Python subprocess in a blocking task with timeout+ // Pass payload via stdin to avoid Windows command-line length limit (os error 206)let result = timeout(Duration::from_secs(timeout_secs),tokio::task::spawn_blocking(move || {- eprintln!("[AgentCmd] Inside blocking task, calling python::execute_sync...");- let exec_result = python::execute_sync(&app_clone, "agents/finagent_core/main.py", args);- eprintln!("[AgentCmd] python::execute_sync returned");+ eprintln!("[AgentCmd] Inside blocking task, calling python::execute_with_stdin...");+ let exec_result = python::execute_with_stdin(&app_clone, "agents/finagent_core/main.py", vec![], &payload_str);+ eprintln!("[AgentCmd] python::execute_with_stdin returned");exec_result})).await;@@ -207,6 +224,16 @@ pub async fn execute_core_agent_streaming(result}+/// Deliver a tool execution result from TypeScript back to the waiting Python agent.+/// TypeScript calls this after executing a terminal MCP tool triggered by the Python agent.+///+/// id: The request ID from the mcp-tool-call event+/// result: JSON string of { success, data, error }+#[tauri::command]+pub fn register_mcp_tool_result(id: String, result: String) -> bool {+ crate::mcp_bridge::deliver_tool_result(&id, result)+}+/// Cancel an active streaming operation#[tauri::command]pub async fn cancel_agent_stream(stream_id: String) -> Result<bool, String> {@@ -348,79 +375,6 @@ pub async fn get_trade_decisions(execute_core_agent(app, payload).await}-// Legacy commands for Node Editor compatibility-fn get_agent_script_path(agent_type: &str) -> Option<&'static str> {- match agent_type {- "warren_buffett" => Some("agents/TraderInvestorsAgent/warren_buffett_agent_cli.py"),- "charlie_munger" => Some("agents/TraderInvestorsAgent/charlie_munger_agent_cli.py"),- "benjamin_graham" => Some("agents/TraderInvestorsAgent/benjamin_graham_agent_cli.py"),- "seth_klarman" => Some("agents/TraderInvestorsAgent/seth_klarman_agent_cli.py"),- "howard_marks" => Some("agents/TraderInvestorsAgent/howard_marks_agent_cli.py"),- "joel_greenblatt" => Some("agents/TraderInvestorsAgent/joel_greenblatt_agent_cli.py"),- "david_einhorn" => Some("agents/TraderInvestorsAgent/david_einhorn_agent_cli.py"),- "bill_miller" => Some("agents/TraderInvestorsAgent/bill_miller_agent_cli.py"),- "jean_marie_eveillard" => Some("agents/TraderInvestorsAgent/jean_marie_eveillard_agent_cli.py"),- "marty_whitman" => Some("agents/TraderInvestorsAgent/marty_whitman_agent_cli.py"),- "macro_cycle" | "central_bank" | "behavioral" | "institutional_flow" |- "innovation" | "geopolitical" | "currency" | "supply_chain" |- "sentiment" | "regulatory" | "bridgewater" | "citadel" |- "two_sigma" | "de_shaw" | "elliott" |- "pershing_square" | "arq_capital" => Some("agents/hedgeFundAgents/hedge_fund_agent_cli.py"),- "renaissance" | "renaissance_technologies" | "rentech" => Some("agents/hedgeFundAgents/renaissance_technologies_hedge_fund_agent/rentech_cli.py"),- "capitalism" => Some("agents/EconomicAgents/capitalism_agent_cli.py"),- "keynesian" => Some("agents/EconomicAgents/keynesian_agent_cli.py"),- "neoliberal" => Some("agents/EconomicAgents/neoliberal_agent_cli.py"),- "socialism" => Some("agents/EconomicAgents/socialism_agent_cli.py"),- "mixed_economy" => Some("agents/EconomicAgents/mixed_economy_agent_cli.py"),- "mercantilist" => Some("agents/EconomicAgents/mercantilist_agent_cli.py"),- _ => None,- }-}--#[tauri::command]-pub async fn execute_python_agent(- app: tauri::AppHandle,- agent_type: String,- parameters: serde_json::Value,- inputs: serde_json::Value,-) -> Result<AgentExecutionResult, String> {- let start_time = std::time::Instant::now();- let script_path = get_agent_script_path(&agent_type)- .ok_or_else(|| format!("Unknown agent type: {}", agent_type))?;-- let args = vec![- "--parameters".to_string(),- serde_json::to_string(¶meters).unwrap_or_default(),- "--inputs".to_string(),- serde_json::to_string(&inputs).unwrap_or_default(),- ];-- let result_str = python::execute_sync(&app, script_path, args)- .map_err(|e| {- let execution_time = start_time.elapsed().as_millis() as u64;- format!("Python execution failed after {}ms: {}", execution_time, e)- })?;-- let execution_time = start_time.elapsed().as_millis() as u64;-- match serde_json::from_str::<serde_json::Value>(&result_str) {- Ok(data) => Ok(AgentExecutionResult {- success: true,- data: Some(data),- error: None,- execution_time_ms: execution_time,- agent_type,- }),- Err(e) => Ok(AgentExecutionResult {- success: true,- data: Some(serde_json::json!({ "raw_output": result_str })),- error: Some(format!("JSON parse warning: {}", e)),- execution_time_ms: execution_time,- agent_type,- }),- }-}-/// Struct for parsing agent definitions from JSON config files#[derive(Debug, Clone, Serialize, Deserialize)]struct AgentDefinition {diff --git a/fincept-terminal-desktop/src-tauri/src/commands/ai_agents.rs b/fincept-terminal-desktop/src-tauri/src/commands/ai_agents.rsdeleted file mode 100644index 026bcffe2..000000000--- a/fincept-terminal-desktop/src-tauri/src/commands/ai_agents.rs+++ /dev/null@@ -1,422 +0,0 @@-// AI Agents Commands - Economic, Geopolitical, Hedge Fund, and Investor agents-#![allow(dead_code)]-use crate::python;--// ECONOMIC AGENTS--/// Execute Economic Agent CLI-#[tauri::command]-pub async fn execute_economic_agent(- app: tauri::AppHandle,- agent_type: String,- command: String,- args: Vec<String>,-) -> Result<String, String> {- let script_name = format!("agents/EconomicAgents/{}_agent_cli.py", agent_type);- let mut cmd_args = vec![command];- cmd_args.extend(args);- python::execute(&app, &script_name, cmd_args).await-}--#[tauri::command]-pub async fn run_capitalism_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/capitalism_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_keynesian_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/keynesian_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_neoliberal_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/neoliberal_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_socialism_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/socialism_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_mercantilist_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/mercantilist_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_mixed_economy_agent(- app: tauri::AppHandle,- analysis_data: String,- parameters: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), analysis_data];- if let Some(p) = parameters {- args.push(p);- }- python::execute(&app, "agents/EconomicAgents/mixed_economy_agent_cli.py", args).await-}--// GEOPOLITICS AGENTS--#[tauri::command]-pub async fn execute_geopolitics_agent(- app: tauri::AppHandle,- command: String,- args: Vec<String>,-) -> Result<String, String> {- let mut cmd_args = vec![command];- cmd_args.extend(args);- python::execute(&app, "agents/GeopoliticsAgents/geopolitics_agent_cli.py", cmd_args).await-}--// Grand Chessboard Agents-#[tauri::command]-pub async fn run_eurasian_chessboard_agent(- app: tauri::AppHandle,- region_data: String,- analysis_type: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), region_data];- if let Some(at) = analysis_type {- args.push(at);- }- python::execute(&app, "agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_chessboard_master_agent.py", args).await-}--#[tauri::command]-pub async fn run_geostrategic_players_agent(- app: tauri::AppHandle,- player_data: String,- strategy_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), player_data];- if let Some(sp) = strategy_params {- args.push(sp);- }- python::execute(&app, "agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/geostrategic_players_agent.py", args).await-}--#[tauri::command]-pub async fn run_eurasian_balkans_agent(- app: tauri::AppHandle,- region_data: String,- analysis_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), region_data];- if let Some(ap) = analysis_params {- args.push(ap);- }- python::execute(&app, "agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_balkans_agent.py", args).await-}--// Prisoners of Geography Agents-#[tauri::command]-pub async fn run_geography_agent(- app: tauri::AppHandle,- region: String,- geographic_data: String,- analysis_type: Option<String>,-) -> Result<String, String> {- let script_name = format!("agents/GeopoliticsAgents/PrisonersOfGeographyAgents/region_agents/{}_geography_agent.py", region);- let mut args = vec!["analyze".to_string(), geographic_data];- if let Some(at) = analysis_type {- args.push(at);- }- python::execute(&app, &script_name, args).await-}--// World Order Agents-#[tauri::command]-pub async fn run_world_order_agent(- app: tauri::AppHandle,- civilization: String,- order_data: String,- analysis_params: Option<String>,-) -> Result<String, String> {- let script_name = format!("agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/{}_world_agent.py", civilization);- let mut args = vec!["analyze".to_string(), order_data];- if let Some(ap) = analysis_params {- args.push(ap);- }- python::execute(&app, &script_name, args).await-}--#[tauri::command]-pub async fn run_westphalian_europe_agent(- app: tauri::AppHandle,- europe_data: String,- diplomatic_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), europe_data];- if let Some(dp) = diplomatic_params {- args.push(dp);- }- python::execute(&app, "agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/westphalian_europe_agent.py", args).await-}--#[tauri::command]-pub async fn run_balance_power_agent(- app: tauri::AppHandle,- power_data: String,- balance_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), power_data];- if let Some(bp) = balance_params {- args.push(bp);- }- python::execute(&app, "agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/balance_power_agent.py", args).await-}--// HEDGE FUND AGENTS--#[tauri::command]-pub async fn execute_hedge_fund_agent(- app: tauri::AppHandle,- command: String,- args: Vec<String>,-) -> Result<String, String> {- let mut cmd_args = vec![command];- cmd_args.extend(args);- python::execute(&app, "agents/hedgeFundAgents/hedge_fund_agent_cli.py", cmd_args).await-}--#[tauri::command]-pub async fn run_bridgewater_agent(- app: tauri::AppHandle,- market_data: String,- strategy_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), market_data];- if let Some(sp) = strategy_params {- args.push(sp);- }- python::execute(&app, "agents/hedgeFundAgents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py", args).await-}--#[tauri::command]-pub async fn run_citadel_agent(- app: tauri::AppHandle,- market_data: String,- trading_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), market_data];- if let Some(tp) = trading_params {- args.push(tp);- }- python::execute(&app, "agents/hedgeFundAgents/citadel_hedge_fund_agent/citadel_agent.py", args).await-}--#[tauri::command]-pub async fn run_renaissance_agent(- app: tauri::AppHandle,- market_data: String,- quant_params: Option<String>,-) -> Result<String, String> {- // Prepare signal data JSON- let signal_data = if let Some(qp) = quant_params {- format!(r#"{{"market_data": {}, "params": {}}}"#, market_data, qp)- } else {- format!(r#"{{"market_data": {}}}"#, market_data)- };-- let args = vec!["analyze".to_string(), signal_data];- python::execute(&app, "agents/hedgeFundAgents/renaissance_technologies_hedge_fund_agent/rentech_cli.py", args).await-}--#[tauri::command]-pub async fn run_de_shaw_agent(- app: tauri::AppHandle,- market_data: String,- computational_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), market_data];- if let Some(cp) = computational_params {- args.push(cp);- }- python::execute(&app, "agents/hedgeFundAgents/de_shaw_hedge_fund_agent/de_shaw_agent.py", args).await-}--#[tauri::command]-pub async fn run_two_sigma_agent(- app: tauri::AppHandle,- market_data: String,- ml_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), market_data];- if let Some(mlp) = ml_params {- args.push(mlp);- }- python::execute(&app, "agents/hedgeFundAgents/two_sigma_hedge_fund_agent/two_sigma_agent.py", args).await-}--#[tauri::command]-pub async fn run_elliott_management_agent(- app: tauri::AppHandle,- market_data: String,- activist_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), market_data];- if let Some(ap) = activist_params {- args.push(ap);- }- python::execute(&app, "agents/hedgeFundAgents/elliott_management_hedge_fund_agent/elliott_management_agent.py", args).await-}--#[tauri::command]-pub async fn run_fincept_hedge_fund_orchestrator(- app: tauri::AppHandle,- market_data: String,- orchestration_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["orchestrate".to_string(), market_data];- if let Some(op) = orchestration_params {- args.push(op);- }- python::execute(&app, "agents/hedgeFundAgents/fincept_hedge_fund/agent_orchestrator.py", args).await-}--// TRADER/INVESTOR AGENTS--#[tauri::command]-pub async fn run_warren_buffett_agent(- app: tauri::AppHandle,- investment_data: String,- value_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(vp) = value_params {- args.push(vp);- }- python::execute(&app, "agents/TraderInvestorsAgent/warren_buffett_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_benjamin_graham_agent(- app: tauri::AppHandle,- investment_data: String,- value_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(vp) = value_params {- args.push(vp);- }- python::execute(&app, "agents/TraderInvestorsAgent/benjamin_graham_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_charlie_munger_agent(- app: tauri::AppHandle,- investment_data: String,- mental_models: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(mm) = mental_models {- args.push(mm);- }- python::execute(&app, "agents/TraderInvestorsAgent/charlie_munger_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_seth_klarman_agent(- app: tauri::AppHandle,- investment_data: String,- margin_of_safety: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(mos) = margin_of_safety {- args.push(mos);- }- python::execute(&app, "agents/TraderInvestorsAgent/seth_klarman_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_howard_marks_agent(- app: tauri::AppHandle,- investment_data: String,- cycle_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(cp) = cycle_params {- args.push(cp);- }- python::execute(&app, "agents/TraderInvestorsAgent/howard_marks_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_joel_greenblatt_agent(- app: tauri::AppHandle,- investment_data: String,- magic_formula_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(mfp) = magic_formula_params {- args.push(mfp);- }- python::execute(&app, "agents/TraderInvestorsAgent/joel_greenblatt_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_david_einhorn_agent(- app: tauri::AppHandle,- investment_data: String,- short_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(sp) = short_params {- args.push(sp);- }- python::execute(&app, "agents/TraderInvestorsAgent/david_einhorn_agent_cli.py", args).await-}--#[tauri::command]-pub async fn run_bill_miller_agent(- app: tauri::AppHandle,- investment_data: String,- contrarian_params: Option<String>,-) -> Result<String, String> {- let mut args = vec!["analyze".to_string(), investment_data];- if let Some(cp) = contrarian_params {- args.push(cp);- }- python::execute(&app, "agents/TraderInvestorsAgent/bill_miller_agent_cli.py", args).await-}diff --git a/fincept-terminal-desktop/src-tauri/src/commands/akshare.rs b/fincept-terminal-desktop/src-tauri/src/commands/akshare.rsindex c6464aff2..e21c2d221 100644--- a/fincept-terminal-desktop/src-tauri/src/commands/akshare.rs+++ b/fincept-terminal-desktop/src-tauri/src/commands/akshare.rs@@ -117,6 +117,19 @@ pub async fn akshare_get_endpoints(app: tauri::AppHandle, script: String) -> Resrun_python_script(&app, &script, "get_all_endpoints")}+// ==================== CHINESE INDEX SPOT (for dashboard widget) ====================++/// Fetches Chinese major index realtime/spot data via AkShare.+/// Uses index_realtime_sw (Shenwan realtime) as primary source.+#[command]+pub async fn fetch_akshare_index_spot(app: tauri::AppHandle) -> Result<String, String> {+ let result = run_python_script_with_args(&app, "akshare_index.py", vec!["index_realtime_sw".to_string()]);+ match result {+ Ok(resp) => serde_json::to_string(&resp).map_err(|e| format!("Serialization error: {}", e)),+ Err(e) => Err(e),+ }+}+// ==================== STOCK MARKET DATA ====================#[command]diff --git a/fincept-terminal-desktop/src-tauri/src/commands/mod.rs b/fincept-terminal-desktop/src-tauri/src/commands/mod.rsindex 3471a85a8..8e8e6553e 100644--- a/fincept-terminal-desktop/src-tauri/src/commands/mod.rs+++ b/fincept-terminal-desktop/src-tauri/src/commands/mod.rs@@ -97,7 +97,6 @@ pub mod financepy;pub mod vollib;// AI Agents-pub mod ai_agents;// Report Generatorpub mod report_generator;@@ -195,3 +194,6 @@ pub mod pypme;// GS-Quant - Goldman Sachs Quant Analyticspub mod gs_quant;++// Polymarket - Prediction markets data+pub mod polymarket;diff --git a/fincept-terminal-desktop/src-tauri/src/commands/polymarket.rs b/fincept-terminal-desktop/src-tauri/src/commands/polymarket.rsnew file mode 100644index 000000000..8a98a8e03--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/src/commands/polymarket.rs@@ -0,0 +1,8 @@+// Polymarket prediction markets data commands+use crate::python;++#[tauri::command]+pub async fn fetch_polymarket_markets(app: tauri::AppHandle, limit: Option<u32>) -> Result<String, String> {+ let limit_str = limit.unwrap_or(10).to_string();+ python::execute(&app, "polymarket.py", vec!["get_markets".to_string(), limit_str]).await+}diff --git a/fincept-terminal-desktop/src-tauri/src/lib.rs b/fincept-terminal-desktop/src-tauri/src/lib.rsindex fe1fca2a3..765655b0f 100644--- a/fincept-terminal-desktop/src-tauri/src/lib.rs+++ b/fincept-terminal-desktop/src-tauri/src/lib.rs@@ -22,6 +22,7 @@ mod websocket;mod services;mod paper_trading;mod market_sim;+pub mod mcp_bridge;// MCP Server Process with communication channelsstruct MCPProcess {@@ -1401,9 +1402,9 @@ pub fn run() {commands::finscript_cmd::execute_finscript,// Python Agent Commandscommands::agents::list_available_agents,- commands::agents::execute_python_agent,commands::agents::get_agent_metadata,commands::agents::execute_core_agent,+ commands::agents::register_mcp_tool_result,commands::agents::read_agent_config,commands::agents::execute_renaissance_cli,// SuperAgent & Planner Commands@@ -1614,37 +1615,6 @@ pub fn run() {commands::vollib::vollib_bsm_greeks,commands::vollib::vollib_bsm_iv,// AI Agent Commands- commands::ai_agents::execute_economic_agent,- commands::ai_agents::run_capitalism_agent,- commands::ai_agents::run_keynesian_agent,- commands::ai_agents::run_neoliberal_agent,- commands::ai_agents::run_socialism_agent,- commands::ai_agents::run_mercantilist_agent,- commands::ai_agents::run_mixed_economy_agent,- commands::ai_agents::execute_geopolitics_agent,- commands::ai_agents::run_eurasian_chessboard_agent,- commands::ai_agents::run_geostrategic_players_agent,- commands::ai_agents::run_eurasian_balkans_agent,- commands::ai_agents::run_geography_agent,- commands::ai_agents::run_world_order_agent,- commands::ai_agents::run_westphalian_europe_agent,- commands::ai_agents::run_balance_power_agent,- commands::ai_agents::execute_hedge_fund_agent,- commands::ai_agents::run_bridgewater_agent,- commands::ai_agents::run_citadel_agent,- commands::ai_agents::run_renaissance_agent,- commands::ai_agents::run_de_shaw_agent,- commands::ai_agents::run_two_sigma_agent,- commands::ai_agents::run_elliott_management_agent,- commands::ai_agents::run_fincept_hedge_fund_orchestrator,- commands::ai_agents::run_warren_buffett_agent,- commands::ai_agents::run_benjamin_graham_agent,- commands::ai_agents::run_charlie_munger_agent,- commands::ai_agents::run_seth_klarman_agent,- commands::ai_agents::run_howard_marks_agent,- commands::ai_agents::run_joel_greenblatt_agent,- commands::ai_agents::run_david_einhorn_agent,- commands::ai_agents::run_bill_miller_agent,// Report Generator Commandscommands::report_generator::generate_report_html,commands::report_generator::generate_report_pdf,@@ -2532,6 +2502,8 @@ pub fn run() {commands::akshare::get_stock_us_info,commands::akshare::check_akshare_db_status,commands::akshare::build_akshare_database,+ commands::akshare::fetch_akshare_index_spot,+ commands::polymarket::fetch_polymarket_markets,// LLM Models Commands (LiteLLM provider and model listing)commands::llm_models::get_llm_providers,commands::llm_models::get_llm_models_by_provider,diff --git a/fincept-terminal-desktop/src-tauri/src/mcp_bridge.rs b/fincept-terminal-desktop/src-tauri/src/mcp_bridge.rsnew file mode 100644index 000000000..5d81e1b99--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/src/mcp_bridge.rs@@ -0,0 +1,241 @@+// mcp_bridge.rs - Local HTTP bridge between Python finagent_core and TypeScript MCP tools+//+// Architecture:+// Python subprocess → POST /tool { id, tool, args }+// → emit Tauri event "mcp-tool-call" to TypeScript+// → TypeScript calls mcpToolService.executeToolDirect() + invoke('register_mcp_tool_result')+// → HTTP response { success, data, error } back to Python+//+// The server binds to 127.0.0.1:0 (random port) and runs as a singleton for the app lifetime.++use dashmap::DashMap;+use once_cell::sync::Lazy;+use std::io::{BufRead, BufReader, Write};+use std::net::TcpListener;+use std::sync::atomic::{AtomicU16, Ordering};+use std::sync::Arc;+use tauri::{AppHandle, Emitter};+use tokio::sync::oneshot;++// Global port (0 = not started)+static BRIDGE_PORT: AtomicU16 = AtomicU16::new(0);++// Pending tool calls: id → oneshot sender for the result JSON string+static PENDING_CALLS: Lazy<Arc<DashMap<String, oneshot::Sender<String>>>> =+ Lazy::new(|| Arc::new(DashMap::new()));++/// Returns the bridge port. Starts the bridge if not already running.+pub fn get_or_start_bridge(app: AppHandle) -> u16 {+ let port = BRIDGE_PORT.load(Ordering::Relaxed);+ if port != 0 {+ return port;+ }+ start_bridge(app)+}++/// Starts the HTTP bridge server. Returns the bound port.+/// Safe to call multiple times — only starts once.+fn start_bridge(app: AppHandle) -> u16 {+ // Bind to random available port on loopback only+ let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind MCP bridge");+ let port = listener.local_addr().expect("No local addr").port();++ // Store port globally+ BRIDGE_PORT.store(port, Ordering::Relaxed);++ eprintln!("[MCPBridge] Started on http://127.0.0.1:{}", port);++ let pending = Arc::clone(&*PENDING_CALLS);++ // Spawn a background OS thread (not tokio) for blocking accept loop+ std::thread::spawn(move || {+ for stream in listener.incoming() {+ match stream {+ Ok(mut stream) => {+ let pending = Arc::clone(&pending);+ let app = app.clone();+ std::thread::spawn(move || {+ handle_connection(&mut stream, pending, app);+ });+ }+ Err(e) => {+ eprintln!("[MCPBridge] Accept error: {}", e);+ }+ }+ }+ });++ port+}++/// Reads and handles a single HTTP request from a TCP stream.+fn handle_connection(+ stream: &mut std::net::TcpStream,+ pending: Arc<DashMap<String, oneshot::Sender<String>>>,+ app: AppHandle,+) {+ // Read HTTP request line + headers+ let mut reader = BufReader::new(stream.try_clone().expect("clone stream"));+ let mut request_line = String::new();+ if reader.read_line(&mut request_line).is_err() {+ return;+ }+ let request_line = request_line.trim().to_string();++ // Read headers to find Content-Length+ let mut content_length: usize = 0;+ loop {+ let mut header = String::new();+ if reader.read_line(&mut header).is_err() {+ break;+ }+ let header = header.trim();+ if header.is_empty() {+ break; // End of headers+ }+ let lower = header.to_lowercase();+ if lower.starts_with("content-length:") {+ if let Ok(n) = lower["content-length:".len()..].trim().parse::<usize>() {+ content_length = n;+ }+ }+ }++ // Parse method + path from request line: "POST /tool HTTP/1.1"+ let parts: Vec<&str> = request_line.splitn(3, ' ').collect();+ if parts.len() < 2 {+ write_response(stream, 400, "Bad Request", b"Bad request line");+ return;+ }+ let method = parts[0];+ let path = parts[1];++ // Read body+ let mut body = vec![0u8; content_length];+ if content_length > 0 {+ use std::io::Read;+ if reader.read_exact(&mut body).is_err() {+ write_response(stream, 400, "Bad Request", b"Failed to read body");+ return;+ }+ }++ match (method, path) {+ ("POST", "/tool") => handle_tool_call(stream, &body, pending, app),+ ("GET", "/health") => write_response(stream, 200, "OK", b"{\"status\":\"ok\"}"),+ ("OPTIONS", _) => write_response(stream, 200, "OK", b""),+ _ => write_response(stream, 404, "Not Found", b"{\"error\":\"not found\"}"),+ }+}++/// Handles POST /tool: { "id": "uuid", "tool": "get_quote", "args": {...} }+fn handle_tool_call(+ stream: &mut std::net::TcpStream,+ body: &[u8],+ pending: Arc<DashMap<String, oneshot::Sender<String>>>,+ app: AppHandle,+) {+ // Parse body as JSON+ let body_json: serde_json::Value = match serde_json::from_slice(body) {+ Ok(v) => v,+ Err(e) => {+ let msg = format!("{{\"error\":\"invalid JSON: {}\"}}", e);+ write_response(stream, 400, "Bad Request", msg.as_bytes());+ return;+ }+ };++ let id = match body_json.get("id").and_then(|v| v.as_str()) {+ Some(s) => s.to_string(),+ None => {+ write_response(stream, 400, "Bad Request", b"{\"error\":\"missing id\"}");+ return;+ }+ };++ let tool_name = match body_json.get("tool").and_then(|v| v.as_str()) {+ Some(s) => s.to_string(),+ None => {+ write_response(stream, 400, "Bad Request", b"{\"error\":\"missing tool\"}");+ return;+ }+ };++ let args = body_json.get("args").cloned().unwrap_or(serde_json::json!({}));++ eprintln!("[MCPBridge] Tool call: id={} tool={}", id, tool_name);++ // Create oneshot channel — we'll block this thread until TypeScript responds+ let (tx, rx) = oneshot::channel::<String>();+ pending.insert(id.clone(), tx);++ // Emit Tauri event to TypeScript+ let event_payload = serde_json::json!({+ "id": id,+ "tool_name": tool_name,+ "args": args,+ });+ if let Err(e) = app.emit("mcp-tool-call", event_payload) {+ eprintln!("[MCPBridge] Failed to emit mcp-tool-call: {}", e);+ pending.remove(&id);+ write_response(stream, 500, "Internal Server Error", b"{\"error\":\"emit failed\"}");+ return;+ }++ // Wait for TypeScript to call register_mcp_tool_result (max 30 seconds).+ // We're on a std thread (not a tokio task), so we create a minimal runtime.+ let result = {+ let rt = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .build()+ .expect("mini runtime for MCP bridge");+ rt.block_on(async {+ tokio::time::timeout(std::time::Duration::from_secs(30), rx).await+ })+ };++ pending.remove(&id);++ match result {+ Ok(Ok(response_str)) => {+ write_response(stream, 200, "OK", response_str.as_bytes());+ }+ Ok(Err(_)) => {+ // Sender dropped+ write_response(stream, 500, "Internal Server Error", b"{\"error\":\"result channel closed\"}");+ }+ Err(_) => {+ // Timeout+ eprintln!("[MCPBridge] Tool call timeout: id={} tool={}", id, tool_name);+ write_response(+ stream,+ 504,+ "Gateway Timeout",+ b"{\"error\":\"tool execution timed out\"}",+ );+ }+ }+}++/// Called by the `register_mcp_tool_result` Tauri command when TypeScript has executed a tool.+pub fn deliver_tool_result(id: &str, result: String) -> bool {+ if let Some((_, tx)) = PENDING_CALLS.remove(id) {+ let _ = tx.send(result);+ true+ } else {+ eprintln!("[MCPBridge] No pending call for id={}", id);+ false+ }+}++/// Writes a minimal HTTP response to the stream.+fn write_response(stream: &mut std::net::TcpStream, status: u16, reason: &str, body: &[u8]) {+ let response = format!(+ "HTTP/1.1 {} {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nAccess-Control-Allow-Origin: *\r\nConnection: close\r\n\r\n",+ status,+ reason,+ body.len()+ );+ let _ = stream.write_all(response.as_bytes());+ let _ = stream.write_all(body);+}diff --git a/fincept-terminal-desktop/src/App.tsx b/fincept-terminal-desktop/src/App.tsxindex b3f3bb562..95cd40e76 100644--- a/fincept-terminal-desktop/src/App.tsx+++ b/fincept-terminal-desktop/src/App.tsx@@ -12,6 +12,7 @@ import { initializeNodeSystem } from './services/nodeSystem';import { initializeStockBrokers } from './brokers/stocks';import { notificationService } from './services/notifications';import { fileStorageService } from './services/fileStorageService';+import { initMCPBridge, destroyMCPBridge } from './services/mcp/mcpBridge';// Import screensimport LoginScreen from './components/auth/LoginScreen';@@ -120,6 +121,12 @@ const App: React.FC = () => {checkSetup();}, []);+ // Initialize MCP bridge so Python agents can call TypeScript internal tools+ useEffect(() => {+ initMCPBridge().catch(err => console.error('[App] MCP bridge init failed:', err));+ return () => { destroyMCPBridge(); };+ }, []);+// Global monitor_alert listener — fires notifications even when MonitoringPanel is not mounteduseEffect(() => {let unlisten: (() => void) | null = null;diff --git a/fincept-terminal-desktop/src/components/tabs/agent-config/AgentConfigTab.tsx b/fincept-terminal-desktop/src/components/tabs/agent-config/AgentConfigTab.tsxindex 44d858c16..f05b63f07 100644--- a/fincept-terminal-desktop/src/components/tabs/agent-config/AgentConfigTab.tsx+++ b/fincept-terminal-desktop/src/components/tabs/agent-config/AgentConfigTab.tsx@@ -10,7 +10,7 @@ import React from 'react';import {Bot, RefreshCw, Route, AlertCircle, CheckCircle,Users, Wrench, MessageSquare, Cpu, ListTree,- GitBranch, Loader2,+ GitBranch, Loader2, Plus,} from 'lucide-react';import { ErrorBoundary } from '@/components/common/ErrorBoundary';import { cacheService } from '@/services/cache/cacheService';@@ -23,11 +23,13 @@ import { PlannerView } from './views/PlannerView';import { ToolsView } from './views/ToolsView';import { ChatView } from './views/ChatView';import { SystemView } from './views/SystemView';+import { CreateAgentView } from './views/CreateAgentView';// ─── View Mode tab definitions (with icons) ──────────────────────────────────const VIEW_MODE_TABS = [{ id: 'agents', name: 'AGENTS', icon: Bot },+ { id: 'create', name: 'CREATE', icon: Plus },{ id: 'teams', name: 'TEAMS', icon: Users },{ id: 'workflows', name: 'WORKFLOWS', icon: GitBranch },{ id: 'planner', name: 'PLANNER', icon: ListTree },@@ -180,6 +182,7 @@ const AgentConfigTab: React.FC = () => {{/* ── Main Content ───────────────────────────────────────────────────── */}<div style={{ flex: 1, overflow: 'hidden' }}>{viewMode === 'agents' && <AgentsView state={state} />}+ {viewMode === 'create' && <CreateAgentView />}{viewMode === 'teams' && <TeamsView state={state} />}{viewMode === 'workflows' && <WorkflowsView state={state} />}{viewMode === 'planner' && <PlannerView state={state} />}diff --git a/fincept-terminal-desktop/src/components/tabs/agent-config/hooks/useAgentConfig.ts b/fincept-terminal-desktop/src/components/tabs/agent-config/hooks/useAgentConfig.tsindex 5085b4151..094de41a3 100644--- a/fincept-terminal-desktop/src/components/tabs/agent-config/hooks/useAgentConfig.ts+++ b/fincept-terminal-desktop/src/components/tabs/agent-config/hooks/useAgentConfig.ts@@ -15,7 +15,9 @@ import agentService, {import {getLLMConfigs,getActiveLLMConfig,+ getAgentConfigs,LLM_PROVIDERS as DB_LLM_PROVIDERS,+ type AgentConfigData,} from '@/services/core/sqliteService';import { portfolioService, type Portfolio } from '@/services/portfolio/portfolioService';import type {@@ -208,6 +210,9 @@ export function useAgentConfig() {loadSystemData().catch(err => {console.warn('System data loading failed (non-critical):', err);});++ // Merge custom agents from SQLite (non-critical, always runs after main load)+ loadCustomAgentsFromDb().catch(() => {});};loadInitialData();@@ -313,6 +318,53 @@ export function useAgentConfig() {setAgentsByCategory({ all: [] });};+ /** Load custom agents from SQLite and merge into discoveredAgents */+ const loadCustomAgentsFromDb = useCallback(async () => {+ try {+ const dbAgents = await getAgentConfigs();+ const customCards: AgentCard[] = dbAgents+ .filter(a => {+ try { return (JSON.parse(a.config_json) as any).user_created === true; } catch { return false; }+ })+ .map(a => {+ let cfg: AgentConfigData = {};+ try { cfg = JSON.parse(a.config_json); } catch {}+ return {+ id: a.id,+ name: a.name,+ description: a.description || '',+ category: a.category,+ version: '1.0',+ provider: cfg.model?.provider || 'custom',+ capabilities: cfg.tools || [],+ config: cfg,+ } as AgentCard;+ });++ if (customCards.length === 0) return;++ setDiscoveredAgents(prev => {+ const existingIds = new Set(prev.map(a => a.id));+ const newOnes = customCards.filter(c => !existingIds.has(c.id));+ if (newOnes.length === 0) return prev;+ return [...prev, ...newOnes];+ });+ setAgentsByCategory(prev => {+ const updated = { ...prev };+ for (const card of customCards) {+ const cat = card.category || 'custom';+ if (!updated[cat]) updated[cat] = [];+ if (!updated[cat].find(a => a.id === card.id)) updated[cat].push(card);+ if (!updated.all) updated.all = [];+ if (!updated.all.find(a => a.id === card.id)) updated.all.push(card);+ }+ return updated;+ });+ } catch (e) {+ // Non-fatal — SQLite custom agents are optional+ }+ }, []);+const setAgentsFromList = (agents: AgentCard[]) => {setDiscoveredAgents(agents);const byCategory: Record<string, AgentCard[]> = { all: agents };@@ -884,6 +936,7 @@ export function useAgentConfig() {workflowSymbol, setWorkflowSymbol, currentPlan, planExecuting,// ActionsloadDiscoveredAgents,+ loadCustomAgentsFromDb,updateEditedConfigFromAgent,runAgent, runTeam, runWorkflow, cancelStream,createPlan, executePlan,diff --git a/fincept-terminal-desktop/src/components/tabs/agent-config/types.ts b/fincept-terminal-desktop/src/components/tabs/agent-config/types.tsindex e1e22c3bd..a68ed4248 100644--- a/fincept-terminal-desktop/src/components/tabs/agent-config/types.ts+++ b/fincept-terminal-desktop/src/components/tabs/agent-config/types.ts@@ -14,7 +14,7 @@ export type { AgentCard, ExecutionPlan, RoutingResult, DbLLMConfig };// ─── View Mode ────────────────────────────────────────────────────────────────-export type ViewMode = 'agents' | 'teams' | 'workflows' | 'planner' | 'tools' | 'system' | 'chat';+export type ViewMode = 'agents' | 'teams' | 'workflows' | 'planner' | 'tools' | 'system' | 'chat' | 'create';// ─── Chat ─────────────────────────────────────────────────────────────────────diff --git a/fincept-terminal-desktop/src/components/tabs/agent-config/views/AgentsView.tsx b/fincept-terminal-desktop/src/components/tabs/agent-config/views/AgentsView.tsxindex 92bafcc75..252fb1342 100644--- a/fincept-terminal-desktop/src/components/tabs/agent-config/views/AgentsView.tsx+++ b/fincept-terminal-desktop/src/components/tabs/agent-config/views/AgentsView.tsx@@ -30,13 +30,14 @@ export const AgentsView: React.FC<AgentsViewProps> = ({ state }) => {showJsonEditor, setShowJsonEditor, jsonText, setJsonText,useAutoRouting, setUseAutoRouting, lastRoutingResult,selectedTools,- loadDiscoveredAgents, updateEditedConfigFromAgent,+ loadDiscoveredAgents, loadCustomAgentsFromDb, updateEditedConfigFromAgent,addToTeam, runAgent,toggleToolSelection,} = state;const handleRefreshAgents = async () => {await loadDiscoveredAgents();+ await loadCustomAgentsFromDb();};return (diff --git a/fincept-terminal-desktop/src/components/tabs/agent-config/views/CreateAgentView.tsx b/fincept-terminal-desktop/src/components/tabs/agent-config/views/CreateAgentView.tsxnew file mode 100644index 000000000..4205c0b04--- /dev/null+++ b/fincept-terminal-desktop/src/components/tabs/agent-config/views/CreateAgentView.tsx@@ -0,0 +1,893 @@+/**+ * CreateAgentView - Build and save custom agents to SQLite+ *+ * Uses the existing agent_configs table + db_save_agent_config Rust command.+ * Custom agents appear immediately in the Agents view after creation.+ */++import React, { useState, useEffect, useCallback, useRef } from 'react';+import {+ Plus, Save, Trash2, Bot, RefreshCw, CheckCircle,+ AlertCircle, Brain, Cpu, Wrench, ChevronDown, ChevronRight,+ Edit3, Loader2, Upload, Download,+} from 'lucide-react';+import {+ saveAgentConfig,+ getAgentConfigsByCategory,+ deleteAgentConfig,+ getLLMConfigs,+ getMCPServers,+ type AgentConfig,+ type AgentConfigData,+ type LLMConfig,+ type MCPServer,+} from '@/services/core/sqliteService';+import { getTools } from '@/services/agentService';+import { FINCEPT } from '../types';++const CATEGORIES = ['custom', 'trader', 'hedge-fund', 'economic', 'geopolitics', 'research', 'general'];++// ─── Default form state ───────────────────────────────────────────────────────++const DEFAULT_FORM = {+ name: '',+ description: '',+ category: 'custom',+ provider: '',+ model_id: '',+ instructions: '',+ temperature: 0.7,+ max_tokens: 4096,+ enable_memory: false,+ enable_agentic_memory: false,+ tools: [] as string[],+ mcp_server_ids: [] as string[],+};++type FormState = typeof DEFAULT_FORM;++// ─── Component ────────────────────────────────────────────────────────────────++export const CreateAgentView: React.FC = () => {+ const [form, setForm] = useState<FormState>(DEFAULT_FORM);+ const [savedAgents, setSavedAgents] = useState<AgentConfig[]>([]);+ const [configuredLLMs, setConfiguredLLMs] = useState<LLMConfig[]>([]);+ const [mcpServers, setMcpServers] = useState<MCPServer[]>([]);+ const [toolCatalog, setToolCatalog] = useState<Record<string, string[]>>({});+ const [saving, setSaving] = useState(false);+ const [loading, setLoading] = useState(false);+ const [deletingId, setDeletingId] = useState<string | null>(null);+ const [notification, setNotification] = useState<{ type: 'success' | 'error'; msg: string } | null>(null);+ const [expandedSection, setExpandedSection] = useState<'basic' | 'model' | 'tools' | 'advanced'>('basic');+ const [editingId, setEditingId] = useState<string | null>(null);+ const importInputRef = useRef<HTMLInputElement>(null);++ // ─── Load LLM configs from Settings ──────────────────────────────────────++ const loadLLMConfigs = useCallback(async () => {+ try {+ const configs = await getLLMConfigs();+ setConfiguredLLMs(configs);+ // Auto-select: fincept first, then active, then first available+ if (configs.length > 0 && !form.provider) {+ const fincept = configs.find(c => c.provider === 'fincept');+ const active = configs.find(c => c.is_active);+ const preferred = fincept || active || configs[0];+ setForm(prev => ({ ...prev, provider: preferred.provider, model_id: preferred.model }));+ }+ } catch {+ // Settings not configured yet — user will see the empty state+ }+ }, []);++ // ─── Load saved custom agents ─────────────────────────────────────────────++ const loadSavedAgents = useCallback(async () => {+ setLoading(true);+ try {+ const agents = await getAgentConfigsByCategory('custom');+ // Also load other user-created categories+ const allCustom = await Promise.all(+ CATEGORIES.slice(1).map(cat => getAgentConfigsByCategory(cat))+ );+ const all = [...agents];+ for (const catAgents of allCustom) {+ for (const a of catAgents) {+ if (!all.find(x => x.id === a.id)) all.push(a);+ }+ }+ // Only show agents where config_json has "user_created": true+ setSavedAgents(all.filter(a => {+ try {+ const cfg = JSON.parse(a.config_json);+ return cfg.user_created === true;+ } catch { return false; }+ }));+ } catch (e: any) {+ // Silently ignore — no agents yet+ } finally {+ setLoading(false);+ }+ }, []);++ const loadMcpServers = useCallback(async () => {+ try {+ const servers = await getMCPServers();+ setMcpServers(servers.filter(s => s.enabled));+ } catch {+ // MCP tab not set up yet — ignore+ }+ }, []);++ const loadToolCatalog = useCallback(async () => {+ try {+ const info = await getTools();+ if (info?.tools) setToolCatalog(info.tools);+ } catch {+ // finagent_core not available — leave empty+ }+ }, []);++ useEffect(() => {+ loadSavedAgents();+ loadLLMConfigs();+ loadMcpServers();+ loadToolCatalog();+ }, [loadSavedAgents, loadLLMConfigs, loadMcpServers, loadToolCatalog]);++ // ─── Notify helper ────────────────────────────────────────────────────────++ const notify = (type: 'success' | 'error', msg: string) => {+ setNotification({ type, msg });+ setTimeout(() => setNotification(null), 4000);+ };++ // ─── Save agent ───────────────────────────────────────────────────────────++ const handleSave = async () => {+ if (!form.name.trim()) { notify('error', 'Agent name is required'); return; }+ if (!form.instructions.trim()) { notify('error', 'Instructions are required'); return; }+ if (!form.provider) { notify('error', 'Select an LLM provider in Model Configuration'); return; }++ setSaving(true);+ try {+ // Build MCP server configs for selected servers+ const selectedMcpServers = form.mcp_server_ids.length > 0+ ? mcpServers+ .filter(s => form.mcp_server_ids.includes(s.id))+ .map(s => ({+ id: s.id,+ name: s.name,+ command: s.command,+ args: (() => { try { return JSON.parse(s.args || '[]'); } catch { return []; } })(),+ env: (() => { try { return JSON.parse(s.env || '{}'); } catch { return {}; } })(),+ transport: 'stdio' as const,+ }))+ : undefined;++ const configData: AgentConfigData & { user_created: boolean } = {+ user_created: true,+ model: {+ provider: form.provider,+ model_id: form.model_id,+ temperature: form.temperature,+ max_tokens: form.max_tokens,+ },+ instructions: form.instructions,+ tools: form.tools,+ memory: form.enable_memory ? { enabled: true } : undefined,+ mcp_servers: selectedMcpServers,+ };++ const id = editingId || `custom_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;++ await saveAgentConfig({+ id,+ name: form.name.trim(),+ description: form.description.trim() || undefined,+ config_json: JSON.stringify(configData),+ category: form.category,+ is_default: false,+ is_active: false,+ });++ notify('success', editingId ? `Agent "${form.name}" updated` : `Agent "${form.name}" created and saved`);+ setForm(DEFAULT_FORM);+ setEditingId(null);+ await loadSavedAgents();+ } catch (e: any) {+ notify('error', `Failed to save: ${e.message || e}`);+ } finally {+ setSaving(false);+ }+ };++ // ─── Delete agent ─────────────────────────────────────────────────────────++ const handleDelete = async (id: string, name: string) => {+ setDeletingId(id);+ try {+ await deleteAgentConfig(id);+ notify('success', `Agent "${name}" deleted`);+ await loadSavedAgents();+ } catch (e: any) {+ notify('error', `Failed to delete: ${e.message || e}`);+ } finally {+ setDeletingId(null);+ }+ };++ // ─── Edit agent ───────────────────────────────────────────────────────────++ const handleEdit = (agent: AgentConfig) => {+ try {+ const cfg = JSON.parse(agent.config_json) as AgentConfigData & { user_created?: boolean };+ setForm({+ name: agent.name,+ description: agent.description || '',+ category: agent.category,+ provider: cfg.model?.provider || '',+ model_id: cfg.model?.model_id || '',+ instructions: cfg.instructions || '',+ temperature: cfg.model?.temperature ?? 0.7,+ max_tokens: cfg.model?.max_tokens ?? 4096,+ enable_memory: cfg.memory?.enabled ?? false,+ enable_agentic_memory: false,+ tools: cfg.tools || [],+ mcp_server_ids: ((cfg as any).mcp_servers || []).map((s: any) => s.id).filter(Boolean),+ });+ setEditingId(agent.id);+ setExpandedSection('model');+ } catch {}+ };++ // ─── Import JSON ──────────────────────────────────────────────────────────++ const handleImport = (e: React.ChangeEvent<HTMLInputElement>) => {+ const file = e.target.files?.[0];+ if (!file) return;+ const reader = new FileReader();+ reader.onload = (ev) => {+ try {+ const raw = JSON.parse(ev.target?.result as string);++ // Accept two shapes:+ // 1. Full agent config_json: { model, instructions, tools, ... }+ // 2. Wrapped export: { name, description, category, config_json: {...} }+ let cfg: AgentConfigData & { user_created?: boolean } = {};+ let meta = { name: '', description: '', category: 'custom' };++ if (raw.config_json) {+ // Wrapped export format+ cfg = typeof raw.config_json === 'string' ? JSON.parse(raw.config_json) : raw.config_json;+ meta.name = raw.name || '';+ meta.description = raw.description || '';+ meta.category = raw.category || 'custom';+ } else if (raw.model || raw.instructions) {+ // Bare config_json format+ cfg = raw;+ } else {+ notify('error', 'Unrecognized JSON format. Expected agent config with "model" or "instructions" fields.');+ return;+ }++ setForm({+ name: meta.name,+ description: meta.description,+ category: CATEGORIES.includes(meta.category) ? meta.category : 'custom',+ provider: cfg.model?.provider || '',+ model_id: cfg.model?.model_id || '',+ temperature: cfg.model?.temperature ?? 0.7,+ max_tokens: cfg.model?.max_tokens ?? 4096,+ instructions: cfg.instructions || '',+ tools: cfg.tools || [],+ enable_memory: cfg.memory?.enabled ?? false,+ enable_agentic_memory: false,+ mcp_server_ids: ((cfg as any).mcp_servers || []).map((s: any) => s.id).filter(Boolean),+ });++ setEditingId(null);+ setExpandedSection('basic');+ notify('success', 'Agent imported — review and click CREATE & SAVE AGENT');+ } catch {+ notify('error', 'Invalid JSON file');+ }+ };+ reader.readAsText(file);+ // Reset input so same file can be re-imported+ e.target.value = '';+ };++ // ─── Export JSON ──────────────────────────────────────────────────────────++ const handleExportAgent = (agent: AgentConfig) => {+ // Export the full wrapped format — same shape that handleImport accepts+ let cfg: Record<string, any> = {};+ try { cfg = JSON.parse(agent.config_json); } catch {}++ const exportData = {+ name: agent.name,+ description: agent.description || '',+ category: agent.category,+ config_json: cfg,+ };++ const blob = new Blob([JSON.stringify(exportData, null, 2)], { type: 'application/json' });+ const url = URL.createObjectURL(blob);+ const a = document.createElement('a');+ a.href = url;+ a.download = `${agent.name.replace(/\s+/g, '_').toLowerCase()}_agent.json`;+ a.click();+ URL.revokeObjectURL(url);+ };++ const handleExportForm = () => {+ if (!form.name.trim()) { notify('error', 'Fill in Agent Name before exporting'); return; }+ const configData = {+ user_created: true,+ model: { provider: form.provider, model_id: form.model_id, temperature: form.temperature, max_tokens: form.max_tokens },+ instructions: form.instructions,+ tools: form.tools,+ memory: form.enable_memory ? { enabled: true } : undefined,+ };+ const exportData = {+ name: form.name.trim(),+ description: form.description.trim(),+ category: form.category,+ config_json: configData,+ };+ const blob = new Blob([JSON.stringify(exportData, null, 2)], { type: 'application/json' });+ const url = URL.createObjectURL(blob);+ const a = document.createElement('a');+ a.href = url;+ a.download = `${form.name.replace(/\s+/g, '_').toLowerCase()}_agent.json`;+ a.click();+ URL.revokeObjectURL(url);+ };++ // ─── Helpers ──────────────────────────────────────────────────────────────++ const toggleTool = (toolId: string) => {+ setForm(prev => ({+ ...prev,+ tools: prev.tools.includes(toolId)+ ? prev.tools.filter(t => t !== toolId)+ : [...prev.tools, toolId],+ }));+ };++ const sectionHeader = (+ id: 'basic' | 'model' | 'tools' | 'advanced',+ label: string,+ icon: React.ReactNode,+ ) => (+ <button+ onClick={() => setExpandedSection(expandedSection === id ? 'basic' : id)}+ style={{+ width: '100%', display: 'flex', alignItems: 'center', gap: '8px',+ padding: '8px 12px', backgroundColor: FINCEPT.HEADER_BG,+ border: `1px solid ${FINCEPT.BORDER}`, borderRadius: '2px',+ cursor: 'pointer', marginBottom: '8px', color: FINCEPT.WHITE,+ }}+ >+ {icon}+ <span style={{ flex: 1, fontSize: '10px', fontWeight: 700, letterSpacing: '0.5px', textAlign: 'left' }}>{label}</span>+ {expandedSection === id ? <ChevronDown size={12} style={{ color: FINCEPT.GRAY }} /> : <ChevronRight size={12} style={{ color: FINCEPT.GRAY }} />}+ </button>+ );++ const labelStyle: React.CSSProperties = { fontSize: '9px', color: FINCEPT.GRAY, letterSpacing: '0.5px', display: 'block', marginBottom: '4px' };+ const inputStyle: React.CSSProperties = {+ width: '100%', padding: '6px 8px', backgroundColor: FINCEPT.DARK_BG,+ color: FINCEPT.WHITE, border: `1px solid ${FINCEPT.BORDER}`,+ borderRadius: '2px', fontSize: '11px', outline: 'none', boxSizing: 'border-box',+ };+ const selectStyle: React.CSSProperties = { ...inputStyle, cursor: 'pointer' };++ // ─── Render ───────────────────────────────────────────────────────────────++ return (+ <div style={{ display: 'flex', height: '100%', overflow: 'hidden' }}>++ {/* LEFT: Builder form */}+ <div style={{ width: '420px', minWidth: '420px', display: 'flex', flexDirection: 'column', borderRight: `1px solid ${FINCEPT.BORDER}`, overflow: 'hidden' }}>++ {/* Hidden file input for import */}+ <input+ ref={importInputRef}+ type="file"+ accept=".json,application/json"+ style={{ display: 'none' }}+ onChange={handleImport}+ />++ {/* Header */}+ <div style={{ padding: '12px 16px', backgroundColor: FINCEPT.HEADER_BG, borderBottom: `1px solid ${FINCEPT.BORDER}`, flexShrink: 0 }}>+ <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: '6px' }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>+ <Plus size={14} style={{ color: FINCEPT.ORANGE }} />+ <span style={{ fontSize: '12px', fontWeight: 700, color: FINCEPT.WHITE, letterSpacing: '0.5px' }}>+ {editingId ? 'EDIT AGENT' : 'CREATE CUSTOM AGENT'}+ </span>+ </div>+ {/* Import / Export current form */}+ <div style={{ display: 'flex', gap: '6px' }}>+ <button+ onClick={() => importInputRef.current?.click()}+ title="Import agent from JSON file"+ style={{ padding: '4px 8px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.CYAN}60`, color: FINCEPT.CYAN, fontSize: '9px', fontWeight: 700, cursor: 'pointer', borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '4px' }}+ >+ <Upload size={10} /> IMPORT+ </button>+ <button+ onClick={handleExportForm}+ title="Export current form as JSON"+ style={{ padding: '4px 8px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.GREEN}60`, color: FINCEPT.GREEN, fontSize: '9px', fontWeight: 700, cursor: 'pointer', borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '4px' }}+ >+ <Download size={10} /> EXPORT+ </button>+ </div>+ </div>+ <span style={{ fontSize: '9px', color: FINCEPT.GRAY }}>+ Agents are saved to SQLite and available immediately in the Agents tab+ </span>+ </div>++ {/* Form */}+ <div style={{ flex: 1, overflow: 'auto', padding: '12px' }}>++ {/* BASIC INFO */}+ {sectionHeader('basic', 'BASIC INFO', <Bot size={12} style={{ color: FINCEPT.ORANGE }} />)}+ {expandedSection === 'basic' && (+ <div style={{ marginBottom: '16px', display: 'flex', flexDirection: 'column', gap: '10px' }}>+ <div>+ <label style={labelStyle}>AGENT NAME *</label>+ <input+ style={inputStyle}+ placeholder="e.g. My Value Investor Agent"+ value={form.name}+ onChange={e => setForm(p => ({ ...p, name: e.target.value }))}+ />+ </div>+ <div>+ <label style={labelStyle}>DESCRIPTION</label>+ <input+ style={inputStyle}+ placeholder="Brief description of what this agent does"+ value={form.description}+ onChange={e => setForm(p => ({ ...p, description: e.target.value }))}+ />+ </div>+ <div>+ <label style={labelStyle}>CATEGORY</label>+ <select style={selectStyle} value={form.category} onChange={e => setForm(p => ({ ...p, category: e.target.value }))}>+ {CATEGORIES.map(c => <option key={c} value={c}>{c.toUpperCase()}</option>)}+ </select>+ </div>+ <div>+ <label style={labelStyle}>INSTRUCTIONS / SYSTEM PROMPT *</label>+ <textarea+ style={{ ...inputStyle, height: '120px', resize: 'vertical', fontFamily: 'inherit' }}+ placeholder="You are a financial analyst specializing in value investing. Analyze stocks using fundamental analysis principles..."+ value={form.instructions}+ onChange={e => setForm(p => ({ ...p, instructions: e.target.value }))}+ />+ </div>+ </div>+ )}++ {/* MODEL CONFIG */}+ {sectionHeader('model', 'MODEL CONFIGURATION', <Cpu size={12} style={{ color: FINCEPT.CYAN }} />)}+ {expandedSection === 'model' && (+ <div style={{ marginBottom: '16px', display: 'flex', flexDirection: 'column', gap: '10px' }}>++ {/* LLM selector — mirrors AgentsView pattern, pulls from Settings */}+ {configuredLLMs.length > 0 ? (+ <div style={{ padding: '10px', backgroundColor: FINCEPT.DARK_BG, border: `1px solid ${FINCEPT.CYAN}40`, borderRadius: '2px' }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px', marginBottom: '8px' }}>+ <CheckCircle size={10} style={{ color: FINCEPT.CYAN }} />+ <span style={{ fontSize: '9px', fontWeight: 700, color: FINCEPT.CYAN, letterSpacing: '0.5px' }}>SELECT LLM PROVIDER</span>+ </div>+ <div style={{ display: 'flex', flexWrap: 'wrap', gap: '6px' }}>+ {configuredLLMs.map((llm, idx) => {+ const hasKey = !!llm.api_key && llm.api_key.length > 0;+ const isSelected = form.provider === llm.provider && form.model_id === llm.model;+ return (+ <button+ key={idx}+ onClick={() => setForm(p => ({ ...p, provider: llm.provider, model_id: llm.model }))}+ style={{+ padding: '6px 10px', cursor: 'pointer', borderRadius: '2px',+ backgroundColor: isSelected ? FINCEPT.ORANGE : FINCEPT.BORDER,+ border: `1px solid ${isSelected ? FINCEPT.ORANGE : FINCEPT.MUTED}`,+ display: 'flex', alignItems: 'center', gap: '5px',+ }}+ >+ {llm.is_active && (+ <span style={{ color: isSelected ? FINCEPT.DARK_BG : FINCEPT.GREEN, fontSize: '8px' }}>●</span>+ )}+ <span style={{ fontSize: '9px', fontWeight: 700, color: isSelected ? FINCEPT.DARK_BG : FINCEPT.WHITE }}>+ {llm.provider.toUpperCase()}+ </span>+ <span style={{ fontSize: '9px', color: isSelected ? FINCEPT.DARK_BG : FINCEPT.GRAY }}>+ / {llm.model}+ </span>+ {!hasKey && <AlertCircle size={9} style={{ color: FINCEPT.RED }} />}+ </button>+ );+ })}+ </div>+ {/* Show selected provider/model */}+ {form.provider && (+ <div style={{ marginTop: '8px', display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '6px' }}>+ <div>+ <div style={{ fontSize: '8px', color: FINCEPT.GRAY, marginBottom: '3px' }}>PROVIDER</div>+ <div style={{ padding: '5px 8px', backgroundColor: FINCEPT.PANEL_BG, border: `1px solid ${FINCEPT.BORDER}`, borderRadius: '2px', fontSize: '10px', color: FINCEPT.CYAN }}>{form.provider}</div>+ </div>+ <div>+ <div style={{ fontSize: '8px', color: FINCEPT.GRAY, marginBottom: '3px' }}>MODEL</div>+ <div style={{ padding: '5px 8px', backgroundColor: FINCEPT.PANEL_BG, border: `1px solid ${FINCEPT.BORDER}`, borderRadius: '2px', fontSize: '10px', color: FINCEPT.CYAN }}>{form.model_id}</div>+ </div>+ </div>+ )}+ </div>+ ) : (+ <div style={{ padding: '12px', backgroundColor: FINCEPT.DARK_BG, border: `1px solid ${FINCEPT.RED}40`, borderRadius: '2px' }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px', marginBottom: '6px' }}>+ <AlertCircle size={10} style={{ color: FINCEPT.RED }} />+ <span style={{ fontSize: '9px', fontWeight: 700, color: FINCEPT.RED }}>NO LLM CONFIGURED</span>+ </div>+ <span style={{ fontSize: '9px', color: FINCEPT.GRAY }}>+ Go to Settings → LLM Configuration to add API keys, then return here.+ </span>+ </div>+ )}++ {/* Temperature + Max Tokens */}+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px' }}>+ <div>+ <label style={labelStyle}>TEMPERATURE ({form.temperature})</label>+ <input+ type="range" min="0" max="2" step="0.1"+ value={form.temperature}+ onChange={e => setForm(p => ({ ...p, temperature: parseFloat(e.target.value) }))}+ style={{ width: '100%', accentColor: FINCEPT.ORANGE }}+ />+ </div>+ <div>+ <label style={labelStyle}>MAX TOKENS</label>+ <input+ style={inputStyle} type="number" min="256" max="32000" step="256"+ value={form.max_tokens}+ onChange={e => setForm(p => ({ ...p, max_tokens: parseInt(e.target.value) || 4096 }))}+ />+ </div>+ </div>+ </div>+ )}++ {/* TOOLS */}+ {sectionHeader('tools', 'TOOLS', <Wrench size={12} style={{ color: FINCEPT.GREEN }} />)}+ {expandedSection === 'tools' && (+ <div style={{ marginBottom: '16px', display: 'flex', flexDirection: 'column', gap: '12px' }}>++ {/* Built-in tools from ToolsRegistry — grouped by category */}+ <div>+ <div style={{ fontSize: '9px', fontWeight: 700, color: FINCEPT.GRAY, letterSpacing: '0.5px', marginBottom: '6px', paddingLeft: '2px' }}>+ BUILT-IN TOOLS ({Object.values(toolCatalog).flat().length})+ </div>+ {Object.keys(toolCatalog).length === 0 ? (+ <div style={{ fontSize: '9px', color: FINCEPT.MUTED, padding: '8px' }}>Loading...</div>+ ) : (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '10px' }}>+ {Object.entries(toolCatalog).map(([category, toolIds]) => (+ <div key={category}>+ <div style={{ fontSize: '8px', fontWeight: 700, color: FINCEPT.ORANGE, letterSpacing: '0.5px', marginBottom: '4px', textTransform: 'uppercase' }}>+ {category.replace(/_/g, ' ')}+ </div>+ <div style={{ display: 'flex', flexDirection: 'column', gap: '4px' }}>+ {toolIds.map(toolId => (+ <div+ key={toolId}+ onClick={() => toggleTool(toolId)}+ style={{+ display: 'flex', alignItems: 'center', gap: '8px',+ padding: '6px 10px', cursor: 'pointer',+ backgroundColor: form.tools.includes(toolId) ? `${FINCEPT.GREEN}15` : FINCEPT.DARK_BG,+ border: `1px solid ${form.tools.includes(toolId) ? FINCEPT.GREEN : FINCEPT.BORDER}`,+ borderRadius: '2px',+ }}+ >+ <div style={{+ width: '12px', height: '12px', borderRadius: '2px', flexShrink: 0,+ backgroundColor: form.tools.includes(toolId) ? FINCEPT.GREEN : 'transparent',+ border: `1px solid ${form.tools.includes(toolId) ? FINCEPT.GREEN : FINCEPT.MUTED}`,+ display: 'flex', alignItems: 'center', justifyContent: 'center',+ }}>+ {form.tools.includes(toolId) && <span style={{ color: FINCEPT.DARK_BG, fontSize: '9px', fontWeight: 700 }}>✓</span>}+ </div>+ <span style={{ fontSize: '10px', color: form.tools.includes(toolId) ? FINCEPT.WHITE : FINCEPT.GRAY, fontWeight: 500 }}>+ {toolId}+ </span>+ </div>+ ))}+ </div>+ </div>+ ))}+ </div>+ )}+ </div>++ {/* MCP Servers from the MCP tab */}+ <div>+ <div style={{ fontSize: '9px', fontWeight: 700, color: FINCEPT.GRAY, letterSpacing: '0.5px', marginBottom: '6px', paddingLeft: '2px', display: 'flex', alignItems: 'center', gap: '6px' }}>+ MCP SERVERS+ <span style={{ fontSize: '8px', color: FINCEPT.MUTED, fontWeight: 400 }}>(configured in MCP tab)</span>+ </div>+ {mcpServers.length === 0 ? (+ <div style={{ padding: '10px', backgroundColor: FINCEPT.DARK_BG, border: `1px solid ${FINCEPT.BORDER}`, borderRadius: '2px', textAlign: 'center' }}>+ <div style={{ fontSize: '9px', color: FINCEPT.MUTED }}>No MCP servers configured</div>+ <div style={{ fontSize: '8px', color: FINCEPT.MUTED, marginTop: '2px' }}>Add servers in the MCP tab to use them here</div>+ </div>+ ) : (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '6px' }}>+ {mcpServers.map(srv => {+ const selected = form.mcp_server_ids.includes(srv.id);+ const isRunning = srv.status === 'running';+ return (+ <div+ key={srv.id}+ onClick={() => setForm(p => ({+ ...p,+ mcp_server_ids: selected+ ? p.mcp_server_ids.filter(id => id !== srv.id)+ : [...p.mcp_server_ids, srv.id],+ }))}+ style={{+ display: 'flex', alignItems: 'center', gap: '8px',+ padding: '8px 10px', cursor: 'pointer',+ backgroundColor: selected ? `${FINCEPT.CYAN}15` : FINCEPT.DARK_BG,+ border: `1px solid ${selected ? FINCEPT.CYAN : FINCEPT.BORDER}`,+ borderRadius: '2px',+ }}+ >+ <div style={{+ width: '14px', height: '14px', borderRadius: '2px', flexShrink: 0,+ backgroundColor: selected ? FINCEPT.CYAN : 'transparent',+ border: `1px solid ${selected ? FINCEPT.CYAN : FINCEPT.MUTED}`,+ display: 'flex', alignItems: 'center', justifyContent: 'center',+ }}>+ {selected && <span style={{ color: FINCEPT.DARK_BG, fontSize: '10px', fontWeight: 700 }}>✓</span>}+ </div>+ <div style={{ flex: 1 }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '5px' }}>+ {srv.icon && <span style={{ fontSize: '10px' }}>{srv.icon}</span>}+ <span style={{ fontSize: '10px', color: selected ? FINCEPT.WHITE : FINCEPT.GRAY, fontWeight: 600 }}>{srv.name}</span>+ <span style={{+ fontSize: '7px', padding: '1px 4px', borderRadius: '2px', fontWeight: 700,+ backgroundColor: isRunning ? `${FINCEPT.GREEN}25` : `${FINCEPT.MUTED}25`,+ color: isRunning ? FINCEPT.GREEN : FINCEPT.MUTED,+ }}>+ {srv.status.toUpperCase()}+ </span>+ </div>+ <div style={{ fontSize: '8px', color: FINCEPT.MUTED }}>{srv.category} · {srv.command}</div>+ </div>+ </div>+ );+ })}+ </div>+ )}+ </div>++ </div>+ )}++ {/* ADVANCED */}+ {sectionHeader('advanced', 'ADVANCED', <Brain size={12} style={{ color: FINCEPT.PURPLE }} />)}+ {expandedSection === 'advanced' && (+ <div style={{ marginBottom: '16px', display: 'flex', flexDirection: 'column', gap: '10px' }}>+ {[+ { key: 'enable_memory' as const, label: 'ENABLE MEMORY', desc: 'Store conversation history between sessions' },+ { key: 'enable_agentic_memory' as const, label: 'ENABLE AGENTIC MEMORY', desc: 'AI builds persistent user memories over time' },+ ].map(({ key, label, desc }) => (+ <div+ key={key}+ onClick={() => setForm(p => ({ ...p, [key]: !p[key] }))}+ style={{+ display: 'flex', alignItems: 'center', gap: '10px',+ padding: '10px', cursor: 'pointer',+ backgroundColor: form[key] ? `${FINCEPT.PURPLE}15` : FINCEPT.DARK_BG,+ border: `1px solid ${form[key] ? FINCEPT.PURPLE : FINCEPT.BORDER}`,+ borderRadius: '2px',+ }}+ >+ <div style={{+ width: '32px', height: '16px', borderRadius: '8px',+ backgroundColor: form[key] ? FINCEPT.PURPLE : FINCEPT.BORDER,+ position: 'relative', flexShrink: 0, transition: 'background 0.2s',+ }}>+ <div style={{+ position: 'absolute', top: '2px',+ left: form[key] ? '18px' : '2px',+ width: '12px', height: '12px', borderRadius: '50%',+ backgroundColor: FINCEPT.WHITE, transition: 'left 0.2s',+ }} />+ </div>+ <div>+ <div style={{ fontSize: '10px', fontWeight: 600, color: form[key] ? FINCEPT.WHITE : FINCEPT.GRAY }}>{label}</div>+ <div style={{ fontSize: '8px', color: FINCEPT.MUTED }}>{desc}</div>+ </div>+ </div>+ ))}+ </div>+ )}+ </div>++ {/* Footer actions */}+ <div style={{ padding: '12px', backgroundColor: FINCEPT.HEADER_BG, borderTop: `1px solid ${FINCEPT.BORDER}`, display: 'flex', gap: '8px', flexShrink: 0 }}>+ {editingId && (+ <button+ onClick={() => { setForm(DEFAULT_FORM); setEditingId(null); }}+ style={{ padding: '8px 12px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.BORDER}`, color: FINCEPT.GRAY, fontSize: '9px', fontWeight: 700, cursor: 'pointer', borderRadius: '2px' }}+ >+ CANCEL+ </button>+ )}+ <button+ onClick={handleSave}+ disabled={saving}+ style={{+ flex: 1, padding: '10px', backgroundColor: FINCEPT.ORANGE,+ border: 'none', color: FINCEPT.DARK_BG, fontSize: '10px', fontWeight: 700,+ cursor: saving ? 'not-allowed' : 'pointer', borderRadius: '2px',+ display: 'flex', alignItems: 'center', justifyContent: 'center', gap: '6px',+ opacity: saving ? 0.7 : 1, letterSpacing: '0.5px',+ }}+ >+ {saving ? <Loader2 size={12} className="animate-spin" /> : <Save size={12} />}+ {saving ? 'SAVING...' : editingId ? 'UPDATE AGENT' : 'CREATE & SAVE AGENT'}+ </button>+ </div>+ </div>++ {/* RIGHT: Saved agents list */}+ <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>++ {/* Header */}+ <div style={{ padding: '12px 16px', backgroundColor: FINCEPT.HEADER_BG, borderBottom: `1px solid ${FINCEPT.BORDER}`, display: 'flex', alignItems: 'center', justifyContent: 'space-between', flexShrink: 0 }}>+ <div>+ <span style={{ fontSize: '12px', fontWeight: 700, color: FINCEPT.WHITE, letterSpacing: '0.5px' }}>SAVED CUSTOM AGENTS</span>+ <span style={{ marginLeft: '8px', fontSize: '9px', color: FINCEPT.GRAY }}>({savedAgents.length})</span>+ </div>+ <button+ onClick={loadSavedAgents}+ disabled={loading}+ style={{ padding: '4px', backgroundColor: 'transparent', border: 'none', cursor: 'pointer' }}+ >+ <RefreshCw size={12} className={loading ? 'animate-spin' : ''} style={{ color: FINCEPT.ORANGE }} />+ </button>+ </div>++ {/* Notification */}+ {notification && (+ <div style={{+ margin: '8px 16px', padding: '10px 12px',+ backgroundColor: notification.type === 'success' ? `${FINCEPT.GREEN}15` : `${FINCEPT.RED}15`,+ border: `1px solid ${notification.type === 'success' ? FINCEPT.GREEN : FINCEPT.RED}40`,+ borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '8px',+ }}>+ {notification.type === 'success'+ ? <CheckCircle size={12} style={{ color: FINCEPT.GREEN }} />+ : <AlertCircle size={12} style={{ color: FINCEPT.RED }} />+ }+ <span style={{ fontSize: '10px', color: notification.type === 'success' ? FINCEPT.GREEN : FINCEPT.RED }}>+ {notification.msg}+ </span>+ </div>+ )}++ {/* Agent list */}+ <div style={{ flex: 1, overflow: 'auto', padding: '12px' }}>+ {loading ? (+ <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', padding: '48px', gap: '12px' }}>+ <Loader2 size={24} className="animate-spin" style={{ color: FINCEPT.ORANGE }} />+ <span style={{ fontSize: '10px', color: FINCEPT.GRAY }}>Loading saved agents...</span>+ </div>+ ) : savedAgents.length === 0 ? (+ <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', padding: '48px', textAlign: 'center', gap: '12px' }}>+ <Bot size={48} style={{ color: FINCEPT.MUTED, opacity: 0.4 }} />+ <div>+ <div style={{ fontSize: '12px', fontWeight: 700, color: FINCEPT.GRAY, marginBottom: '4px' }}>NO CUSTOM AGENTS YET</div>+ <div style={{ fontSize: '10px', color: FINCEPT.MUTED }}>Create your first agent using the builder on the left</div>+ </div>+ </div>+ ) : (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>+ {savedAgents.map(agent => {+ let cfg: AgentConfigData & { user_created?: boolean } = {};+ try { cfg = JSON.parse(agent.config_json); } catch {}++ return (+ <div key={agent.id} style={{+ padding: '14px', backgroundColor: FINCEPT.PANEL_BG,+ border: `1px solid ${editingId === agent.id ? FINCEPT.ORANGE : FINCEPT.BORDER}`,+ borderRadius: '2px',+ }}>+ <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: '8px', marginBottom: '8px' }}>+ <div style={{ flex: 1, minWidth: 0 }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '8px', marginBottom: '4px', flexWrap: 'wrap' }}>+ <span style={{ fontSize: '12px', fontWeight: 700, color: FINCEPT.WHITE }}>{agent.name}</span>+ <span style={{ padding: '2px 6px', backgroundColor: `${FINCEPT.CYAN}20`, color: FINCEPT.CYAN, fontSize: '8px', borderRadius: '2px' }}>+ {agent.category.toUpperCase()}+ </span>+ <span style={{ padding: '2px 6px', backgroundColor: `${FINCEPT.PURPLE}20`, color: FINCEPT.PURPLE, fontSize: '8px', borderRadius: '2px' }}>+ {cfg.model?.provider?.toUpperCase() || 'UNKNOWN'}+ </span>+ </div>+ {agent.description && (+ <div style={{ fontSize: '10px', color: FINCEPT.GRAY, marginBottom: '4px' }}>{agent.description}</div>+ )}+ <div style={{ fontSize: '9px', color: FINCEPT.MUTED }}>+ Model: {cfg.model?.model_id || 'N/A'} · Temp: {cfg.model?.temperature ?? 'N/A'}+ {(cfg.tools?.length ?? 0) > 0 && ` · Tools: ${cfg.tools!.join(', ')}`}+ </div>+ </div>+ <div style={{ display: 'flex', gap: '4px', flexShrink: 0 }}>+ <button+ onClick={() => handleEdit(agent)}+ style={{ padding: '4px 8px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.BORDER}`, color: FINCEPT.WHITE, fontSize: '9px', cursor: 'pointer', borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '4px' }}+ >+ <Edit3 size={10} /> EDIT+ </button>+ <button+ onClick={() => handleExportAgent(agent)}+ title="Export agent as JSON"+ style={{ padding: '4px 8px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.GREEN}60`, color: FINCEPT.GREEN, fontSize: '9px', cursor: 'pointer', borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '4px' }}+ >+ <Download size={10} /> JSON+ </button>+ <button+ onClick={() => handleDelete(agent.id, agent.name)}+ disabled={deletingId === agent.id}+ style={{ padding: '4px 8px', backgroundColor: 'transparent', border: `1px solid ${FINCEPT.RED}40`, color: FINCEPT.RED, fontSize: '9px', cursor: 'pointer', borderRadius: '2px', display: 'flex', alignItems: 'center', gap: '4px', opacity: deletingId === agent.id ? 0.5 : 1 }}+ >+ {deletingId === agent.id ? <Loader2 size={10} className="animate-spin" /> : <Trash2 size={10} />}+ DELETE+ </button>+ </div>+ </div>++ {/* Instructions preview */}+ {cfg.instructions && (+ <div style={{+ padding: '8px', backgroundColor: FINCEPT.DARK_BG,+ border: `1px solid ${FINCEPT.BORDER}`, borderRadius: '2px',+ fontSize: '9px', color: FINCEPT.MUTED,+ overflow: 'hidden', maxHeight: '40px',+ display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical',+ }}>+ {cfg.instructions}+ </div>+ )}++ <div style={{ marginTop: '8px', fontSize: '8px', color: FINCEPT.MUTED }}>+ Created: {new Date(agent.created_at).toLocaleDateString()} · ID: {agent.id.slice(0, 24)}...+ </div>+ </div>+ );+ })}+ </div>+ )}+ </div>++ {/* Footer hint */}+ <div style={{ padding: '8px 16px', backgroundColor: FINCEPT.HEADER_BG, borderTop: `1px solid ${FINCEPT.BORDER}`, flexShrink: 0 }}>+ <span style={{ fontSize: '9px', color: FINCEPT.MUTED }}>+ Custom agents are saved to SQLite and automatically appear in AGENTS tab under their category. Use them in the Node Editor, Teams, and Chat.+ </span>+ </div>+ </div>+ </div>+ );+};diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/BacktestingTab.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/BacktestingTab.tsxindex 74155cd45..5185e8f63 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/BacktestingTab.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/BacktestingTab.tsx@@ -10,8 +10,9 @@ import React from 'react';import { FINCEPT, COMMON_STYLES } from '../portfolio-tab/finceptStyles';import { useTerminalTheme } from '@/contexts/ThemeContext';import { useBacktestingState } from './hooks';-import { TopNavBar, CommandPanel, ConfigPanel, ResultsPanel, StatusBar, StatsRibbon } from './components';+import { TopNavBar } from './components';import { VectorBTDashboard } from './providers/vectorbt';+import { FinceptDashboard } from './providers/fincept/FinceptDashboard';const BacktestingTab: React.FC = () => {const state = useBacktestingState();@@ -38,29 +39,9 @@ const BacktestingTab: React.FC = () => {<TopNavBar state={state} />{state.selectedProvider === 'vectorbt' ? (- /* ═══ VECTORBT: Full Dashboard UI ═══ */<VectorBTDashboard state={state} />) : (- /* ═══ GENERIC LAYOUT (other providers) ═══ */- <>- {/* ═══ STATS RIBBON (52px) ═══ */}- <StatsRibbon state={state} />-- {/* ═══ MAIN CONTENT ═══ */}- <div style={{ flex: 1, display: 'flex', overflow: 'hidden' }}>- {/* LEFT: Commands + Categories (220px) */}- <CommandPanel state={state} />-- {/* CENTER: Configuration (flex:1) */}- <ConfigPanel state={state} />-- {/* RIGHT: Results (320px) */}- <ResultsPanel state={state} />- </div>-- {/* ═══ STATUS BAR (24px) ═══ */}- <StatusBar state={state} />- </>+ <FinceptDashboard state={state} />)}</div>);diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/components/CommandPanel.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/components/CommandPanel.tsxindex f7692fe80..bdce40c89 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/components/CommandPanel.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/components/CommandPanel.tsx@@ -1,11 +1,11 @@/**- * CommandPanel - Left sidebar (220px) with command list + strategy categories- * Matches portfolio HoldingsHeatmap sidebar pattern: dense, watchlist-style items+ * CommandPanel - Left sidebar: NodePalette-identical structure.+ * Commands as expandable category + Strategy categories as items with dot+name.*/-import React from 'react';-import { ChevronRight } from 'lucide-react';-import { FINCEPT, TYPOGRAPHY, SPACING, EFFECTS } from '../../portfolio-tab/finceptStyles';+import React, { useState } from 'react';+import { Layers, Search, ChevronDown } from 'lucide-react';+import { FINCEPT, EFFECTS } from '../../portfolio-tab/finceptStyles';import { PROVIDER_COLORS } from '../constants';import type { BacktestingState } from '../types';@@ -19,164 +19,300 @@ export const CommandPanel: React.FC<CommandPanelProps> = ({ state }) => {providerCommands, providerCategoryInfo, providerStrategies,selectedCategory, setSelectedCategory,} = state;+const providerColor = PROVIDER_COLORS[selectedProvider];+ const totalCommands = providerCommands.length;++ const [searchQuery, setSearchQuery] = useState('');+ const [cmdExpanded, setCmdExpanded] = useState(true);+ const [stratExpanded, setStratExpanded] = useState(true);++ const filteredCommands = providerCommands.filter(cmd =>+ cmd.label.toLowerCase().includes(searchQuery.toLowerCase()) ||+ (cmd.description || '').toLowerCase().includes(searchQuery.toLowerCase())+ );++ const showStrategies = ['backtest', 'optimize', 'walk_forward'].includes(activeCommand);return (<div style={{- width: '220px',+ width: '240px',flexShrink: 0,- backgroundColor: FINCEPT.PANEL_BG,- borderRight: `1px solid ${FINCEPT.BORDER}`,+ borderRight: '1px solid #2a2a2a',display: 'flex',flexDirection: 'column',- overflow: 'hidden',+ height: '100%',+ backgroundColor: '#000000',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',}}>- {/* Commands Header */}++ {/* ── Header ── */}<div style={{- padding: `${SPACING.MEDIUM} ${SPACING.DEFAULT}`,- backgroundColor: FINCEPT.HEADER_BG,- borderBottom: `1px solid ${FINCEPT.BORDER}`,+ padding: '10px 12px',+ backgroundColor: '#0f0f0f',+ borderBottom: '1px solid #2a2a2a',display: 'flex',alignItems: 'center',justifyContent: 'space-between',+ flexShrink: 0,}}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '7px' }}>+ <Layers size={13} style={{ color: '#FF8800' }} />+ <span style={{ color: '#FF8800', fontSize: '10px', fontWeight: 700, letterSpacing: '0.8px' }}>+ COMMANDS+ </span>+ </div><span style={{- fontSize: TYPOGRAPHY.TINY,- fontWeight: TYPOGRAPHY.BOLD,- color: FINCEPT.ORANGE,- letterSpacing: '0.5px',- textTransform: 'uppercase',- }}>- COMMANDS- </span>- <span style={{- fontSize: '8px',- fontWeight: TYPOGRAPHY.BOLD,+ fontSize: '8px', fontWeight: 700,color: providerColor,padding: '1px 5px',- backgroundColor: `${providerColor}15`,+ backgroundColor: `${providerColor}20`,+ border: `1px solid ${providerColor}40`,borderRadius: '2px',+ letterSpacing: '0.3px',}}>- {providerCommands.length}+ {selectedProvider.toUpperCase()}</span></div>- {/* Command List */}- <div style={{ flex: 1, overflowY: 'auto' }}>- {providerCommands.map(cmd => {- const Icon = cmd.icon;- const isActive = activeCommand === cmd.id;-- return (- <div- key={cmd.id}- onClick={() => setActiveCommand(cmd.id)}- className="bt-row"+ {/* ── Search ── */}+ <div style={{+ padding: '8px 10px',+ borderBottom: '1px solid #2a2a2a',+ backgroundColor: '#000000',+ flexShrink: 0,+ }}>+ <div style={{ position: 'relative' }}>+ <Search size={11} style={{+ position: 'absolute', left: '8px', top: '50%',+ transform: 'translateY(-50%)', color: '#787878', pointerEvents: 'none',+ }} />+ <input+ type="text"+ value={searchQuery}+ onChange={e => setSearchQuery(e.target.value)}+ placeholder="Search commands..."+ style={{+ width: '100%', backgroundColor: '#0f0f0f',+ border: '1px solid #2a2a2a', borderRadius: '2px',+ padding: '6px 8px 6px 26px', color: '#ffffff',+ fontSize: '10px', fontFamily: '"IBM Plex Mono", Consolas, monospace',+ outline: 'none', boxSizing: 'border-box' as const,+ transition: 'border-color 0.15s',+ }}+ onFocus={e => (e.currentTarget.style.borderColor = '#FF8800')}+ onBlur={e => (e.currentTarget.style.borderColor = '#2a2a2a')}+ />+ </div>+ <div style={{ color: '#787878', fontSize: '9px', marginTop: '5px', letterSpacing: '0.3px' }}>+ {totalCommands} COMMANDS AVAILABLE+ </div>+ </div>++ {/* ── Scrollable body ── */}+ <div style={{ flex: 1, overflowY: 'auto', overflowX: 'hidden' }}>++ {/* Commands category */}+ <div>+ <button+ onClick={() => setCmdExpanded(v => !v)}+ style={{+ width: '100%', padding: '7px 10px', backgroundColor: '#0f0f0f',+ border: 'none', borderBottom: '1px solid #2a2a2a',+ display: 'flex', alignItems: 'center', justifyContent: 'space-between',+ cursor: 'pointer', transition: 'background-color 0.15s',+ }}+ onMouseEnter={e => (e.currentTarget.style.backgroundColor = '#1a1a1a')}+ onMouseLeave={e => (e.currentTarget.style.backgroundColor = '#0f0f0f')}+ >+ <div style={{ display: 'flex', alignItems: 'center', gap: '7px' }}>+ <span style={{ fontSize: '9px', fontWeight: 700, color: '#d4d4d4', letterSpacing: '0.5px' }}>+ OPERATIONS+ </span>+ <span style={{+ fontSize: '8px', color: '#787878', backgroundColor: '#1a1a1a',+ border: '1px solid #2a2a2a', borderRadius: '2px', padding: '1px 4px',+ }}>+ {filteredCommands.length}+ </span>+ </div>+ <ChevronDown size={11} style={{+ color: '#787878',+ transform: cmdExpanded ? 'rotate(0deg)' : 'rotate(-90deg)',+ transition: 'transform 0.15s',+ }} />+ </button>++ {cmdExpanded && (+ <div style={{ padding: '4px 6px 6px', backgroundColor: '#000000', borderBottom: '1px solid #1a1a1a' }}>+ {filteredCommands.map(cmd => {+ const Icon = cmd.icon;+ const isActive = activeCommand === cmd.id;+ const cmdColor = (cmd as any).color || '#FF8800';+ return (+ <div+ key={cmd.id}+ onClick={() => setActiveCommand(cmd.id)}+ style={{+ backgroundColor: isActive ? `${cmdColor}15` : '#0f0f0f',+ border: `1px solid ${isActive ? cmdColor + '50' : '#2a2a2a'}`,+ borderLeft: `2px solid ${isActive ? cmdColor : '#2a2a2a'}`,+ borderRadius: '2px', padding: '6px 8px', marginBottom: '3px',+ cursor: 'pointer', transition: 'all 0.15s',+ display: 'flex', alignItems: 'center', gap: '8px',+ }}+ onMouseEnter={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = `${cmdColor}10`;+ e.currentTarget.style.borderColor = `${cmdColor}50`;+ e.currentTarget.style.borderLeftColor = cmdColor;+ e.currentTarget.style.borderLeftWidth = '2px';+ }+ }}+ onMouseLeave={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = '#0f0f0f';+ e.currentTarget.style.borderColor = '#2a2a2a';+ e.currentTarget.style.borderLeftWidth = '1px';+ }+ }}+ >+ <div style={{+ width: '6px', height: '6px', borderRadius: '50%',+ backgroundColor: isActive ? cmdColor : '#787878', flexShrink: 0,+ boxShadow: isActive ? `0 0 4px ${cmdColor}60` : 'none',+ }} />+ <div style={{ flex: 1, minWidth: 0 }}>+ <div style={{+ color: isActive ? '#ffffff' : '#d4d4d4', fontSize: '10px',+ fontWeight: 700, letterSpacing: '0.3px',+ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',+ }}>+ {cmd.label}+ </div>+ {cmd.description && (+ <div style={{+ color: '#787878', fontSize: '8px', marginTop: '2px',+ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',+ }}>+ {cmd.description}+ </div>+ )}+ </div>+ </div>+ );+ })}+ </div>+ )}+ </div>++ {/* Strategy categories (shown only for backtest/optimize/walk_forward) */}+ {showStrategies && (+ <div>+ <button+ onClick={() => setStratExpanded(v => !v)}style={{- padding: '8px 10px',- backgroundColor: isActive ? `${FINCEPT.ORANGE}08` : 'transparent',- borderLeft: isActive ? `2px solid ${FINCEPT.ORANGE}` : '2px solid transparent',- cursor: 'pointer',- transition: EFFECTS.TRANSITION_FAST,- display: 'flex',- alignItems: 'center',- gap: '6px',+ width: '100%', padding: '7px 10px', backgroundColor: '#0f0f0f',+ border: 'none', borderBottom: '1px solid #2a2a2a',+ display: 'flex', alignItems: 'center', justifyContent: 'space-between',+ cursor: 'pointer', transition: 'background-color 0.15s',}}+ onMouseEnter={e => (e.currentTarget.style.backgroundColor = '#1a1a1a')}+ onMouseLeave={e => (e.currentTarget.style.backgroundColor = '#0f0f0f')}>- <Icon size={10} color={isActive ? FINCEPT.ORANGE : FINCEPT.MUTED} style={isActive ? { filter: EFFECTS.ICON_GLOW_ORANGE } : undefined} />- <div style={{ flex: 1, minWidth: 0 }}>- <div style={{- fontSize: '10px',- fontWeight: TYPOGRAPHY.BOLD,- color: isActive ? FINCEPT.WHITE : FINCEPT.GRAY,- letterSpacing: '0.3px',- }}>- {cmd.label}- </div>- <div style={{- fontSize: '8px',- color: FINCEPT.MUTED,- marginTop: '1px',- whiteSpace: 'nowrap',- overflow: 'hidden',- textOverflow: 'ellipsis',+ <div style={{ display: 'flex', alignItems: 'center', gap: '7px' }}>+ <span style={{ fontSize: '9px', fontWeight: 700, color: '#d4d4d4', letterSpacing: '0.5px' }}>+ STRATEGIES+ </span>+ <span style={{+ fontSize: '8px', color: '#787878', backgroundColor: '#1a1a1a',+ border: '1px solid #2a2a2a', borderRadius: '2px', padding: '1px 4px',}}>- {cmd.description}- </div>+ {Object.keys(providerCategoryInfo).length}+ </span></div>- <ChevronRight size={9} color={isActive ? FINCEPT.ORANGE : FINCEPT.MUTED} style={{ flexShrink: 0 }} />- </div>- );- })}- </div>+ <ChevronDown size={11} style={{+ color: '#787878',+ transform: stratExpanded ? 'rotate(0deg)' : 'rotate(-90deg)',+ transition: 'transform 0.15s',+ }} />+ </button>- {/* Strategy Categories */}- {['backtest', 'optimize', 'walk_forward'].includes(activeCommand) && (- <>- <div style={{- padding: `${SPACING.MEDIUM} ${SPACING.DEFAULT}`,- backgroundColor: FINCEPT.HEADER_BG,- borderTop: `1px solid ${FINCEPT.BORDER}`,- borderBottom: `1px solid ${FINCEPT.BORDER}`,- display: 'flex',- alignItems: 'center',- justifyContent: 'space-between',- }}>- <span style={{- fontSize: TYPOGRAPHY.TINY,- fontWeight: TYPOGRAPHY.BOLD,- color: FINCEPT.ORANGE,- letterSpacing: '0.5px',- }}>- STRATEGIES- </span>- </div>- <div style={{ overflowY: 'auto', maxHeight: '260px' }}>- {Object.entries(providerCategoryInfo).map(([key, info]: [string, any]) => {- const CatIcon = info.icon;- const isActive = selectedCategory === key;- const count = providerStrategies[key]?.length || 0;-- return (- <div- key={key}- onClick={() => setSelectedCategory(key)}- className="bt-row"- style={{- padding: '6px 10px',- backgroundColor: isActive ? `${info.color}08` : 'transparent',- borderLeft: isActive ? `2px solid ${info.color}` : '2px solid transparent',- cursor: 'pointer',- transition: EFFECTS.TRANSITION_FAST,- display: 'flex',- alignItems: 'center',- gap: '6px',- }}- >- <CatIcon size={9} color={isActive ? info.color : FINCEPT.MUTED} />- <span style={{- fontSize: TYPOGRAPHY.TINY,- fontWeight: TYPOGRAPHY.BOLD,- color: isActive ? FINCEPT.WHITE : FINCEPT.GRAY,- flex: 1,- letterSpacing: '0.3px',- textTransform: 'uppercase',- }}>- {info.label}- </span>- <span style={{- fontSize: '8px',- fontWeight: TYPOGRAPHY.BOLD,- color: isActive ? info.color : FINCEPT.MUTED,- }}>- {count}- </span>- </div>- );- })}+ {stratExpanded && (+ <div style={{ padding: '4px 6px 6px', backgroundColor: '#000000', borderBottom: '1px solid #1a1a1a' }}>+ {Object.entries(providerCategoryInfo).map(([key, info]: [string, any]) => {+ const CatIcon = info.icon;+ const isActive = selectedCategory === key;+ const count = providerStrategies[key]?.length || 0;+ return (+ <div+ key={key}+ onClick={() => setSelectedCategory(key)}+ style={{+ backgroundColor: isActive ? `${info.color}15` : '#0f0f0f',+ border: `1px solid ${isActive ? info.color + '50' : '#2a2a2a'}`,+ borderLeft: `2px solid ${isActive ? info.color : '#2a2a2a'}`,+ borderRadius: '2px', padding: '6px 8px', marginBottom: '3px',+ cursor: 'pointer', transition: 'all 0.15s',+ display: 'flex', alignItems: 'center', gap: '8px',+ }}+ onMouseEnter={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = `${info.color}10`;+ e.currentTarget.style.borderColor = `${info.color}50`;+ e.currentTarget.style.borderLeftColor = info.color;+ e.currentTarget.style.borderLeftWidth = '2px';+ }+ }}+ onMouseLeave={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = '#0f0f0f';+ e.currentTarget.style.borderColor = '#2a2a2a';+ e.currentTarget.style.borderLeftWidth = '1px';+ }+ }}+ >+ <div style={{+ width: '6px', height: '6px', borderRadius: '50%',+ backgroundColor: isActive ? info.color : '#787878', flexShrink: 0,+ boxShadow: isActive ? `0 0 4px ${info.color}60` : 'none',+ }} />+ <div style={{ flex: 1, minWidth: 0 }}>+ <div style={{+ color: isActive ? '#ffffff' : '#d4d4d4', fontSize: '10px',+ fontWeight: 700, letterSpacing: '0.3px',+ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',+ }}>+ {info.label}+ </div>+ </div>+ <span style={{+ fontSize: '8px', color: isActive ? info.color : '#787878',+ backgroundColor: '#1a1a1a', border: '1px solid #2a2a2a',+ borderRadius: '2px', padding: '1px 4px', flexShrink: 0,+ }}>+ {count}+ </span>+ </div>+ );+ })}+ </div>+ )}</div>- </>- )}+ )}+ </div>++ {/* ── Footer ── */}+ <div style={{+ padding: '6px 10px', borderTop: '1px solid #2a2a2a', backgroundColor: '#0f0f0f',+ display: 'flex', alignItems: 'center', justifyContent: 'center',+ gap: '6px', flexShrink: 0,+ }}>+ <div style={{ width: '4px', height: '4px', borderRadius: '50%', backgroundColor: '#FF8800' }} />+ <span style={{ color: '#4a4a4a', fontSize: '8px', letterSpacing: '0.5px', fontWeight: 700 }}>+ CLICK TO SELECT COMMAND+ </span>+ </div></div>);};diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/components/StatsRibbon.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/components/StatsRibbon.tsxindex 04b3ec047..0c6ff5bfd 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/components/StatsRibbon.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/components/StatsRibbon.tsx@@ -1,11 +1,10 @@/**- * StatsRibbon - 52px metric cells for last backtest results- * Matches portfolio StatsRibbon pattern: 3-line cells (label, value, sub)+ * StatsRibbon - Horizontal metrics row matching VBMetricsCards style.+ * Label on top, big value, sublabel below. Dark card bg, no borders.*/import React, { useMemo } from 'react';-import { FINCEPT } from '../../portfolio-tab/finceptStyles';-import { getValueColor } from '../../portfolio-tab/finceptStyles';+import { FINCEPT, TYPOGRAPHY, getValueColor } from '../../portfolio-tab/finceptStyles';import { PROVIDER_COLORS } from '../constants';import type { BacktestingState } from '../types';@@ -26,11 +25,11 @@ export const StatsRibbon: React.FC<StatsRibbonProps> = ({ state }) => {{ label: 'SYMBOL', value: symbols.toUpperCase() || '--', sub: activeCommand.toUpperCase().replace('_', ' '), color: FINCEPT.CYAN },{ label: 'TOTAL RETURN', value: fmtPct(perf?.total_return), sub: 'CUMULATIVE', color: perf?.total_return != null ? getValueColor(perf.total_return) : FINCEPT.GRAY },{ label: 'SHARPE', value: fmt(perf?.sharpe_ratio), sub: 'ANNUALIZED', color: FINCEPT.CYAN },- { label: 'MAX DRAWDOWN', value: fmtPct(perf?.max_drawdown), sub: 'PEAK-TROUGH', color: FINCEPT.RED },+ { label: 'MAX DD', value: fmtPct(perf?.max_drawdown), sub: 'PEAK-TROUGH', color: FINCEPT.RED },{ label: 'WIN RATE', value: perf?.win_rate != null ? `${fmt(perf.win_rate)}%` : '--', sub: 'TRADES', color: FINCEPT.GREEN },- { label: 'PROFIT FACTOR', value: fmt(perf?.profit_factor), sub: 'GROSS P/L', color: perf?.profit_factor > 1 ? FINCEPT.GREEN : FINCEPT.RED },- { label: 'TOTAL TRADES', value: perf?.total_trades != null ? String(perf.total_trades) : '--', sub: 'EXECUTED', color: FINCEPT.WHITE },- { label: 'ANNUAL RETURN', value: fmtPct(perf?.annual_return), sub: 'CAGR', color: perf?.annual_return != null ? getValueColor(perf.annual_return) : FINCEPT.GRAY },+ { label: 'P. FACTOR', value: fmt(perf?.profit_factor), sub: 'GROSS P/L', color: perf?.profit_factor > 1 ? FINCEPT.GREEN : FINCEPT.RED },+ { label: 'TRADES', value: perf?.total_trades != null ? String(perf.total_trades) : '--', sub: 'EXECUTED', color: FINCEPT.WHITE },+ { label: 'ANN. RETURN', value: fmtPct(perf?.annual_return), sub: 'CAGR', color: perf?.annual_return != null ? getValueColor(perf.annual_return) : FINCEPT.GRAY },{ label: 'VOLATILITY', value: perf?.annual_volatility != null ? `${fmt(perf.annual_volatility)}%` : '--', sub: 'ANN.', color: FINCEPT.ORANGE },{ label: 'SORTINO', value: fmt(perf?.sortino_ratio), sub: 'DOWNSIDE', color: FINCEPT.CYAN },{ label: 'CALMAR', value: fmt(perf?.calmar_ratio), sub: 'RATIO', color: FINCEPT.YELLOW },@@ -40,39 +39,46 @@ export const StatsRibbon: React.FC<StatsRibbonProps> = ({ state }) => {return (<div style={{- height: '52px',flexShrink: 0,- backgroundColor: '#0A0A0A',- borderBottom: `1px solid ${FINCEPT.BORDER}`,+ padding: '6px 8px',display: 'flex',- alignItems: 'stretch',- overflow: 'hidden',+ gap: '4px',+ borderBottom: `1px solid #2a2a2a`,+ backgroundColor: '#000000',+ overflowX: 'auto',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',}}>- {cells.map((m, i) => (- <div key={i} style={{- flex: 1,- minWidth: '80px',- padding: '6px 8px',- borderRight: '1px solid #141414',- display: 'flex',- flexDirection: 'column',- justifyContent: 'center',- }}>+ {cells.map((cell, i) => (+ <div+ key={i}+ style={{+ flex: '1 1 0',+ minWidth: '72px',+ padding: '8px 10px',+ backgroundColor: '#0f0f0f',+ borderRadius: '2px',+ display: 'flex',+ flexDirection: 'column',+ justifyContent: 'center',+ gap: '2px',+ }}+ ><div style={{- fontSize: '8px', color: FINCEPT.GRAY, fontWeight: 700,- letterSpacing: '0.5px', lineHeight: 1, marginBottom: '3px',+ fontSize: '8px', fontWeight: 700, color: '#787878',+ letterSpacing: '0.5px', lineHeight: 1,}}>- {m.label}+ {cell.label}</div><div style={{- fontSize: '14px', fontWeight: 800, color: m.color, lineHeight: 1,+ fontSize: '13px', fontWeight: 800,+ color: isRunning && i > 0 && i < 11 ? FINCEPT.ORANGE : cell.color,+ lineHeight: 1, letterSpacing: '-0.3px',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',}}>- {isRunning && i > 0 && i < 11 ? '...' : m.value}+ {isRunning && i > 0 && i < 11 ? '...' : cell.value}</div>- <div style={{- fontSize: '8px', color: FINCEPT.GRAY, marginTop: '2px', lineHeight: 1,- }}>- {m.sub}+ <div style={{ fontSize: '8px', color: '#4a4a4a', lineHeight: 1 }}>+ {cell.sub}</div></div>))}diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/fincept/FinceptDashboard.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/fincept/FinceptDashboard.tsxnew file mode 100644index 000000000..e23043ca2--- /dev/null+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/fincept/FinceptDashboard.tsx@@ -0,0 +1,90 @@+/**+ * FinceptDashboard - Mirrors VectorBTDashboard layout exactly.+ *+ * Layout:+ * TopNavBar (40px) ← rendered by BacktestingTab+ * [CommandPanel (240px) | StatsRibbon + Chart + BottomTabs | ResultsPanel (320px)]+ * StatusBar (24px)+ */++import React from 'react';+import { FINCEPT, COMMON_STYLES } from '../../../portfolio-tab/finceptStyles';+import { StatusBar } from '../../components/StatusBar';+import { CommandPanel } from '../../components/CommandPanel';+import { StatsRibbon } from '../../components/StatsRibbon';+import { ConfigPanel } from '../../components/ConfigPanel';+import { ResultsPanel } from '../../components/ResultsPanel';+import { VBChartPanel } from '../vectorbt/VBChartPanel';+import { VBBottomTabs } from '../vectorbt/VBBottomTabs';+import type { BacktestingState } from '../../types';++interface FinceptDashboardProps {+ state: BacktestingState;+}++const BACKTEST_COMMANDS = new Set(['backtest', 'optimize', 'walk_forward']);++export const FinceptDashboard: React.FC<FinceptDashboardProps> = ({ state }) => {+ const isBacktestCommand = BACKTEST_COMMANDS.has(state.activeCommand);++ return (+ <div style={{+ height: '100%',+ display: 'flex',+ flexDirection: 'column',+ backgroundColor: '#000000',+ overflow: 'hidden',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',+ }}>+ <style>{`+ ${COMMON_STYLES.scrollbarCSS}+ @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.4; } }+ @keyframes fadeIn { from { opacity: 0; transform: translateY(4px); } to { opacity: 1; transform: translateY(0); } }+ `}</style>++ {/* ═══ MAIN CONTENT ═══ */}+ <div style={{ flex: 1, display: 'flex', overflow: 'hidden' }}>++ {/* LEFT: Command Panel (240px, NodePalette style) */}+ <CommandPanel state={state} />++ {/* CENTER+RIGHT: mirrors VectorBTDashboard right area */}+ {isBacktestCommand ? (+ <div style={{ flex: 1, display: 'flex', overflow: 'hidden' }}>++ {/* CENTER: Metrics + Chart + BottomTabs (same as VBT) */}+ <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>+ <StatsRibbon state={state} />+ <VBChartPanel state={state} />+ <VBBottomTabs state={state} />+ </div>++ {/* RIGHT: Config + Results stacked (320px) */}+ <div style={{+ width: '320px',+ flexShrink: 0,+ display: 'flex',+ flexDirection: 'column',+ overflow: 'hidden',+ borderLeft: '1px solid #2a2a2a',+ }}>+ <ConfigPanel state={state} />+ </div>+ </div>+ ) : (+ /* Non-backtest: metrics + config + results side by side */+ <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>+ <StatsRibbon state={state} />+ <div style={{ flex: 1, display: 'flex', overflow: 'hidden' }}>+ <ConfigPanel state={state} />+ <ResultsPanel state={state} />+ </div>+ </div>+ )}+ </div>++ {/* ═══ STATUS BAR (24px) ═══ */}+ <StatusBar state={state} />+ </div>+ );+};diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBChartPanel.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBChartPanel.tsxindex 65a15a0d4..8235a5df8 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBChartPanel.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBChartPanel.tsx@@ -25,22 +25,25 @@ export const VBChartPanel: React.FC<VBChartPanelProps> = ({ state }) => {const trades = result?.data?.trades;const benchmark = result?.data?.benchmark;+ // Normalize any date string to yyyy-mm-dd+ const toDateStr = (raw: string): string => raw.split('T')[0].split(' ')[0].substring(0, 10);+// Parse equity curve dataconst equityPoints = useMemo(() => {if (!equityData) return [];if (Array.isArray(equityData)) {return equityData.map((pt: any) => {- if (pt.time && pt.value !== undefined) return pt;- if (pt.date && pt.equity !== undefined) return { time: pt.date, value: pt.equity };- if (pt.date && pt.value !== undefined) return { time: pt.date, value: pt.value };+ if (pt.time && pt.value !== undefined) return { time: toDateStr(pt.time), value: pt.value };+ if (pt.date && pt.equity !== undefined) return { time: toDateStr(pt.date), value: pt.equity };+ if (pt.date && pt.value !== undefined) return { time: toDateStr(pt.date), value: pt.value };if (pt.timestamp && pt.equity !== undefined)- return { time: new Date(pt.timestamp).toISOString().split('T')[0], value: pt.equity };+ return { time: toDateStr(new Date(pt.timestamp).toISOString()), value: pt.equity };return null;}).filter(Boolean);}if (typeof equityData === 'object') {return Object.entries(equityData).map(([date, value]) => ({- time: date,+ time: toDateStr(date),value: Number(value),})).sort((a, b) => a.time.localeCompare(b.time));}@@ -52,15 +55,15 @@ export const VBChartPanel: React.FC<VBChartPanelProps> = ({ state }) => {if (!benchmark) return [];if (Array.isArray(benchmark)) {return benchmark.map((pt: any) => {- if (pt.time && pt.value !== undefined) return pt;- if (pt.date && pt.equity !== undefined) return { time: pt.date, value: pt.equity };- if (pt.date && pt.value !== undefined) return { time: pt.date, value: pt.value };+ if (pt.time && pt.value !== undefined) return { time: toDateStr(pt.time), value: pt.value };+ if (pt.date && pt.equity !== undefined) return { time: toDateStr(pt.date), value: pt.equity };+ if (pt.date && pt.value !== undefined) return { time: toDateStr(pt.date), value: pt.value };return null;}).filter(Boolean);}if (typeof benchmark === 'object') {return Object.entries(benchmark).map(([date, value]) => ({- time: date,+ time: toDateStr(date),value: Number(value),})).sort((a, b) => a.time.localeCompare(b.time));}@@ -74,7 +77,7 @@ export const VBChartPanel: React.FC<VBChartPanelProps> = ({ state }) => {trades.forEach((trade: any) => {if (trade.entryDate || trade.entry_date) {m.push({- time: trade.entryDate || trade.entry_date,+ time: toDateStr(trade.entryDate || trade.entry_date),position: 'belowBar' as const,color: '#00D66F',shape: 'arrowUp' as const,@@ -83,7 +86,7 @@ export const VBChartPanel: React.FC<VBChartPanelProps> = ({ state }) => {}if (trade.exitDate || trade.exit_date) {m.push({- time: trade.exitDate || trade.exit_date,+ time: toDateStr(trade.exitDate || trade.exit_date),position: 'aboveBar' as const,color: '#FF3B3B',shape: 'arrowDown' as const,diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBCommandBar.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBCommandBar.tsxindex 56b84ee70..931a952a5 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBCommandBar.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBCommandBar.tsx@@ -71,41 +71,46 @@ export const VBCommandBar: React.FC<VBCommandBarProps> = ({ state }) => {flexShrink: 0,}} />- {/* Command pills */}+ {/* Command squares */}<div style={{display: 'flex',- gap: '4px',+ gap: '3px',flexShrink: 0,- overflowX: 'auto',}}>{providerCommands.map(cmd => {const isActive = activeCommand === cmd.id;const Icon = cmd.icon;+ const cmdColor = (cmd as any).color || FINCEPT.ORANGE;return (<buttonkey={cmd.id}- className={isActive ? undefined : 'vb-pill'}onClick={() => setActiveCommand(cmd.id)}+ title={cmd.label}style={{- padding: '6px 14px',- backgroundColor: isActive ? FINCEPT.ORANGE : 'transparent',- color: isActive ? FINCEPT.DARK_BG : FINCEPT.GRAY,- border: isActive ? 'none' : BORDERS.STANDARD,+ width: '60px',+ height: '40px',+ backgroundColor: isActive ? `${cmdColor}20` : FINCEPT.DARK_BG,+ color: isActive ? cmdColor : FINCEPT.MUTED,+ border: `1px solid ${isActive ? cmdColor : FINCEPT.BORDER}`,borderRadius: '3px',- fontSize: '10px',+ fontSize: '8px',fontWeight: 700,cursor: 'pointer',- letterSpacing: '0.5px',+ letterSpacing: '0.3px',textTransform: 'uppercase' as const,display: 'flex',+ flexDirection: 'column' as const,alignItems: 'center',- gap: '5px',+ justifyContent: 'center',+ gap: '3px',transition: EFFECTS.TRANSITION_FAST,- whiteSpace: 'nowrap' as const,+ fontFamily: TYPOGRAPHY.MONO,}}+ onMouseEnter={e => { if (!isActive) { e.currentTarget.style.borderColor = cmdColor; e.currentTarget.style.color = cmdColor; } }}+ onMouseLeave={e => { if (!isActive) { e.currentTarget.style.borderColor = FINCEPT.BORDER; e.currentTarget.style.color = FINCEPT.MUTED; } }}>- <Icon size={12} />- {cmd.label}+ <Icon size={13} />+ <span style={{ lineHeight: 1.2, fontSize: '7px', textAlign: 'center' as const }}>{cmd.label}</span></button>);})}diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBMetricsCards.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBMetricsCards.tsxindex 5b7b8aeb7..66d728e31 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBMetricsCards.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBMetricsCards.tsx@@ -1,12 +1,11 @@/**- * VBMetricsCards - Horizontal row of large metric cards- * Replaces both VBStatsRibbon and VBMetricsPanel top section.- * 6 key metrics displayed as prominent cards with big numbers.+ * VBMetricsCards - Horizontal row of metric cards+ * AI Quant Lab style: label on top, big value below, compact dark cards.*/import React from 'react';import {- FINCEPT, TYPOGRAPHY, BORDERS,+ FINCEPT, TYPOGRAPHY,getValueColor, formatPercentage, formatCurrency,} from '../../../portfolio-tab/finceptStyles';import type { BacktestingState } from '../../types';@@ -24,13 +23,6 @@ interface MetricCardDef {}const METRIC_CARDS: MetricCardDef[] = [- {- key: 'totalReturn',- label: 'RETURN',- sublabel: 'Total P&L',- format: v => formatPercentage(v * 100),- color: v => getValueColor(v),- },{key: 'sharpeRatio',label: 'SHARPE',@@ -75,6 +67,7 @@ export const VBMetricsCards: React.FC<VBMetricsCardsProps> = ({ state }) => {const totalReturn = perf?.totalReturn;const hasReturn = typeof totalReturn === 'number' && isFinite(totalReturn);const endValue = hasReturn ? initialCapital * (1 + totalReturn) : null;+ const returnColor = hasReturn ? getValueColor(totalReturn) : FINCEPT.MUTED;return (<div style={{@@ -86,90 +79,105 @@ export const VBMetricsCards: React.FC<VBMetricsCardsProps> = ({ state }) => {backgroundColor: FINCEPT.PANEL_BG,overflowX: 'auto',}}>- {/* Summary card - wider, shows capital flow */}+ {/* ── Return card (wider) ── */}<div style={{- minWidth: '120px',+ minWidth: '130px',flex: '0 0 auto',- padding: '10px 14px',- backgroundColor: FINCEPT.HEADER_BG,- border: BORDERS.STANDARD,+ padding: '10px 12px',+ backgroundColor: FINCEPT.DARK_BG,borderRadius: '3px',+ borderLeft: `3px solid ${returnColor}`,display: 'flex',flexDirection: 'column',justifyContent: 'center',- borderLeft: `3px solid ${hasReturn ? getValueColor(totalReturn) : FINCEPT.MUTED}`,+ gap: '3px',}}><div style={{- fontSize: '20px',+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ }}>+ <span style={{+ fontSize: '9px',+ fontWeight: 700,+ color: FINCEPT.GRAY,+ letterSpacing: '0.5px',+ fontFamily: TYPOGRAPHY.MONO,+ }}>RETURN</span>+ {hasReturn && (+ <span style={{+ fontSize: '8px',+ fontWeight: 700,+ padding: '1px 5px',+ backgroundColor: `${FINCEPT.GREEN}20`,+ color: FINCEPT.GREEN,+ borderRadius: '2px',+ fontFamily: TYPOGRAPHY.MONO,+ }}>DONE</span>+ )}+ </div>+ <div style={{+ fontSize: '18px',fontWeight: 800,- color: isRunning- ? FINCEPT.ORANGE- : hasReturn- ? getValueColor(totalReturn)- : FINCEPT.MUTED,+ color: isRunning ? FINCEPT.ORANGE : returnColor,fontFamily: TYPOGRAPHY.MONO,- letterSpacing: '-1px',+ letterSpacing: '-0.5px',lineHeight: 1.1,animation: isRunning ? 'pulse 1s infinite' : 'none',}}>{isRunning ? '...' : hasReturn ? formatPercentage(totalReturn * 100) : '--'}</div>- <div style={{- fontSize: '9px',- color: FINCEPT.GRAY,- marginTop: '4px',- fontFamily: TYPOGRAPHY.MONO,- }}>- {hasReturn && endValue !== null- ? `${formatCurrency(initialCapital)} \u2192 ${formatCurrency(endValue)}`- : 'TOTAL RETURN'- }- </div>- {hasReturn && (+ {hasReturn && endValue !== null && (<div style={{- display: 'inline-block',- marginTop: '4px',- padding: '1px 6px',- backgroundColor: `${FINCEPT.GREEN}20`,- color: FINCEPT.GREEN,fontSize: '8px',- fontWeight: 700,- borderRadius: '2px',- width: 'fit-content',+ color: FINCEPT.MUTED,+ fontFamily: TYPOGRAPHY.MONO,}}>- DONE+ {formatCurrency(initialCapital)} → {formatCurrency(endValue)}</div>)}</div>- {/* Individual metric cards */}- {METRIC_CARDS.slice(1).map(card => {+ {/* ── Individual metric cards ── */}+ {METRIC_CARDS.map(card => {const rawValue = perf?.[card.key];const hasValue = typeof rawValue === 'number' && isFinite(rawValue);+ const valueColor = isRunning ? FINCEPT.ORANGE : hasValue ? card.color(rawValue) : FINCEPT.MUTED;return (<divkey={card.key}style={{- minWidth: '90px',+ minWidth: '80px',flex: '1 1 0',padding: '10px 12px',- backgroundColor: FINCEPT.HEADER_BG,- border: BORDERS.STANDARD,+ backgroundColor: FINCEPT.DARK_BG,borderRadius: '3px',display: 'flex',flexDirection: 'column',justifyContent: 'center',+ gap: '3px',}}>+ {/* Label row */}+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '4px',+ }}>+ <span style={{+ fontSize: '9px',+ fontWeight: 700,+ color: FINCEPT.GRAY,+ letterSpacing: '0.5px',+ fontFamily: TYPOGRAPHY.MONO,+ }}>{card.label}</span>+ </div>+ {/* Value */}<div style={{- fontSize: '18px',+ fontSize: '16px',fontWeight: 800,- color: isRunning- ? FINCEPT.ORANGE- : hasValue- ? card.color(rawValue)- : FINCEPT.MUTED,+ color: valueColor,fontFamily: TYPOGRAPHY.MONO,letterSpacing: '-0.5px',lineHeight: 1.1,@@ -177,19 +185,11 @@ export const VBMetricsCards: React.FC<VBMetricsCardsProps> = ({ state }) => {}}>{isRunning ? '...' : hasValue ? card.format(rawValue) : '--'}</div>- <div style={{- fontSize: '9px',- fontWeight: 700,- color: FINCEPT.GRAY,- marginTop: '4px',- letterSpacing: '0.5px',- }}>- {card.label}- </div>+ {/* Sublabel */}<div style={{fontSize: '8px',color: FINCEPT.MUTED,- marginTop: '1px',+ fontFamily: TYPOGRAPHY.MONO,}}>{card.sublabel}</div>diff --git a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBStrategyPanel.tsx b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBStrategyPanel.tsxindex decbd034c..9a3b269b5 100644--- a/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBStrategyPanel.tsx+++ b/fincept-terminal-desktop/src/components/tabs/backtesting/providers/vectorbt/VBStrategyPanel.tsx@@ -1,13 +1,12 @@/**- * VBStrategyPanel - Left 300px panel with card-based category selector,- * strategy cards with left color bars, parameter inputs, and advanced config.- *- * Redesign: card grid categories, 11px strategy names, 10px+ labels.+ * VBStrategyPanel - NodePalette-identical structure.+ * Header / Search / Expandable category headers / Strategy items with dot+name+description / Footer*/-import React, { useMemo } from 'react';+import React, { useMemo, useState } from 'react';+import { Layers, Search, ChevronDown } from 'lucide-react';import {- FINCEPT, TYPOGRAPHY, EFFECTS, COMMON_STYLES, BORDERS, SPACING,+ FINCEPT, TYPOGRAPHY, EFFECTS, BORDERS,createFocusHandlers,} from '../../../portfolio-tab/finceptStyles';import { POSITION_SIZING } from '../../constants';@@ -46,164 +45,274 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {} = state;const categories = useMemo(() => Object.keys(providerStrategies), [providerStrategies]);- const strategies = useMemo(- () => providerStrategies[selectedCategory] || [],- [providerStrategies, selectedCategory]+ const totalCount = useMemo(+ () => categories.reduce((sum, cat) => sum + (providerStrategies[cat]?.length || 0), 0),+ [categories, providerStrategies]);++ const [searchQuery, setSearchQuery] = useState('');+ const [expandedCategories, setExpandedCategories] = useState<Set<string>>(+ () => new Set(categories)+ );++ const toggleCategory = (cat: string) => {+ const next = new Set(expandedCategories);+ if (next.has(cat)) next.delete(cat); else next.add(cat);+ setExpandedCategories(next);+ };++ // Filter strategies by search+ const filteredStrategies = useMemo(() => {+ const q = searchQuery.toLowerCase().trim();+ if (!q) return providerStrategies;+ const result: typeof providerStrategies = {};+ categories.forEach(cat => {+ const filtered = (providerStrategies[cat] || []).filter((s: any) =>+ s.name.toLowerCase().includes(q) || (s.description || '').toLowerCase().includes(q)+ );+ if (filtered.length > 0) result[cat] = filtered;+ });+ return result;+ }, [searchQuery, providerStrategies, categories]);+const focus = createFocusHandlers();return (<div style={{width: '300px',flexShrink: 0,- borderRight: `1px solid ${FINCEPT.BORDER}`,+ borderRight: `1px solid #2a2a2a`,display: 'flex',flexDirection: 'column',- overflow: 'hidden',- backgroundColor: FINCEPT.PANEL_BG,+ height: '100%',+ backgroundColor: '#000000',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',}}>+{/* ── Header ── */}<div style={{- padding: '10px 14px',- backgroundColor: FINCEPT.HEADER_BG,- borderBottom: `1px solid ${FINCEPT.BORDER}`,+ padding: '10px 12px',+ backgroundColor: '#0f0f0f',+ borderBottom: '1px solid #2a2a2a',display: 'flex',alignItems: 'center',justifyContent: 'space-between',flexShrink: 0,}}>- <span style={{- fontSize: '11px',- fontWeight: 700,- color: FINCEPT.ORANGE,- letterSpacing: '0.5px',- }}>- STRATEGIES- </span>- <span style={{- fontSize: '10px',- color: FINCEPT.GRAY,- fontFamily: TYPOGRAPHY.MONO,- }}>- {strategies.length} available- </span>+ <div style={{ display: 'flex', alignItems: 'center', gap: '7px' }}>+ <Layers size={13} style={{ color: '#FF8800' }} />+ <span style={{+ color: '#FF8800',+ fontSize: '10px',+ fontWeight: 700,+ letterSpacing: '0.8px',+ }}>+ STRATEGIES+ </span>+ </div></div>- {/* ── Category Card Grid ── */}+ {/* ── Search ── */}<div style={{padding: '8px 10px',- borderBottom: `1px solid ${FINCEPT.BORDER}`,- display: 'grid',- gridTemplateColumns: 'repeat(3, 1fr)',- gap: '4px',+ borderBottom: '1px solid #2a2a2a',+ backgroundColor: '#000000',flexShrink: 0,}}>- {categories.map(cat => {- const info = providerCategoryInfo[cat];- const isActive = selectedCategory === cat;- const count = (providerStrategies[cat] || []).length;- if (count === 0) return null;+ <div style={{ position: 'relative' }}>+ <Search size={11} style={{+ position: 'absolute',+ left: '8px',+ top: '50%',+ transform: 'translateY(-50%)',+ color: '#787878',+ pointerEvents: 'none',+ }} />+ <input+ type="text"+ value={searchQuery}+ onChange={e => setSearchQuery(e.target.value)}+ placeholder="Search strategies..."+ style={{+ width: '100%',+ backgroundColor: '#0f0f0f',+ border: '1px solid #2a2a2a',+ borderRadius: '2px',+ padding: '6px 8px 6px 26px',+ color: '#ffffff',+ fontSize: '10px',+ fontFamily: '"IBM Plex Mono", Consolas, monospace',+ outline: 'none',+ boxSizing: 'border-box' as const,+ transition: 'border-color 0.15s',+ }}+ onFocus={e => (e.currentTarget.style.borderColor = '#FF8800')}+ onBlur={e => (e.currentTarget.style.borderColor = '#2a2a2a')}+ />+ </div>+ <div style={{ color: '#787878', fontSize: '9px', marginTop: '5px', letterSpacing: '0.3px' }}>+ {totalCount} STRATEGIES AVAILABLE+ </div>+ </div>++ {/* ── Category + Strategy List ── */}+ <div style={{ flex: 1, overflowY: 'auto', overflowX: 'hidden' }}>+ {Object.keys(filteredStrategies).length === 0 && (+ <div style={{ padding: '32px 16px', textAlign: 'center' as const }}>+ <Search size={20} style={{ color: '#2a2a2a', margin: '0 auto 10px' }} />+ <div style={{ fontSize: '9px', fontWeight: 700, color: '#787878', letterSpacing: '0.5px' }}>+ NO STRATEGIES FOUND+ </div>+ <div style={{ fontSize: '9px', color: '#4a4a4a', marginTop: '4px' }}>+ Try a different search term+ </div>+ </div>+ )}- const catColor = info?.color || FINCEPT.ORANGE;+ {Object.keys(filteredStrategies).map(cat => {+ const info = providerCategoryInfo[cat];+ const strategies = filteredStrategies[cat] || [];+ if (strategies.length === 0) return null;+ const catColor = info?.color || '#FF8800';const CatIcon = info?.icon;+ const isExpanded = expandedCategories.has(cat);return (- <button- key={cat}- onClick={() => {- setSelectedCategory(cat);- const first = providerStrategies[cat]?.[0];- if (first) setSelectedStrategy(first.id);- }}- style={{- padding: '6px 8px',- backgroundColor: isActive ? `${catColor}15` : 'transparent',- color: isActive ? catColor : FINCEPT.GRAY,- border: isActive ? `1px solid ${catColor}` : BORDERS.STANDARD,- borderLeft: isActive ? `3px solid ${catColor}` : `3px solid transparent`,- borderRadius: '3px',- fontSize: '10px',- fontWeight: 700,- cursor: 'pointer',- letterSpacing: '0.3px',- textTransform: 'uppercase' as const,- transition: EFFECTS.TRANSITION_FAST,- display: 'flex',- flexDirection: 'column',- alignItems: 'center',- gap: '2px',- textAlign: 'center' as const,- }}- >- {CatIcon && <CatIcon size={14} style={{ opacity: isActive ? 1 : 0.5 }} />}- <span style={{ fontSize: '9px', lineHeight: 1.2 }}>- {info?.label || cat}- </span>- <span style={{- fontSize: '9px',- fontWeight: 600,- color: isActive ? catColor : FINCEPT.MUTED,- backgroundColor: isActive ? `${catColor}20` : 'transparent',- padding: '0 4px',- borderRadius: '2px',- }}>- {count}- </span>- </button>- );- })}- </div>-- {/* ── Strategy List ── */}- <div style={{ flex: 1, overflowY: 'auto', padding: '6px' }}>- {strategies.map((strat: any) => {- const isActive = selectedStrategy === strat.id;- const catInfo = providerCategoryInfo[selectedCategory];- const catColor = catInfo?.color || FINCEPT.ORANGE;+ <div key={cat}>+ {/* Category Header */}+ <button+ onClick={() => toggleCategory(cat)}+ style={{+ width: '100%',+ padding: '7px 10px',+ backgroundColor: '#0f0f0f',+ border: 'none',+ borderBottom: '1px solid #2a2a2a',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between',+ cursor: 'pointer',+ transition: 'background-color 0.15s',+ }}+ onMouseEnter={e => (e.currentTarget.style.backgroundColor = '#1a1a1a')}+ onMouseLeave={e => (e.currentTarget.style.backgroundColor = '#0f0f0f')}+ >+ <div style={{ display: 'flex', alignItems: 'center', gap: '7px' }}>+ {CatIcon && (+ <span style={{ color: catColor, display: 'flex', alignItems: 'center' }}>+ <CatIcon size={12} />+ </span>+ )}+ <span style={{+ fontSize: '9px',+ fontWeight: 700,+ color: '#d4d4d4',+ letterSpacing: '0.5px',+ }}>+ {(info?.label || cat).toUpperCase()}+ </span>+ <span style={{+ fontSize: '8px',+ color: '#787878',+ backgroundColor: '#1a1a1a',+ border: '1px solid #2a2a2a',+ borderRadius: '2px',+ padding: '1px 4px',+ letterSpacing: '0.3px',+ }}>+ {strategies.length}+ </span>+ </div>+ <ChevronDown size={11} style={{+ color: '#787878',+ transform: isExpanded ? 'rotate(0deg)' : 'rotate(-90deg)',+ transition: 'transform 0.15s',+ }} />+ </button>- return (- <div- key={strat.id}- className="vb-strat"- onClick={() => setSelectedStrategy(strat.id)}- style={{- padding: '10px 12px',- cursor: 'pointer',- borderLeft: `3px solid ${isActive ? catColor : 'transparent'}`,- backgroundColor: isActive ? `${catColor}08` : 'transparent',- transition: EFFECTS.TRANSITION_FAST,- marginBottom: '2px',- borderRadius: '2px',- minHeight: '44px',- }}- >- <div style={{- fontSize: '11px',- fontWeight: isActive ? 700 : 600,- color: isActive ? FINCEPT.WHITE : FINCEPT.GRAY,- marginBottom: '3px',- }}>- {strat.name}- </div>- <div style={{- fontSize: '9px',- color: FINCEPT.MUTED,- lineHeight: 1.4,- marginBottom: strat.params?.length > 0 ? '4px' : '0',- }}>- {strat.description}- </div>- {/* Inline param preview */}- {strat.params?.length > 0 && (+ {/* Strategy Items */}+ {isExpanded && (<div style={{- fontSize: '10px',- color: FINCEPT.CYAN,- fontFamily: TYPOGRAPHY.MONO,- opacity: 0.8,+ padding: '4px 6px 6px',+ backgroundColor: '#000000',+ borderBottom: '1px solid #1a1a1a',}}>- {strat.params.map((p: any) =>- `${p.label.toLowerCase()}=${state.strategyParams[p.name] ?? p.default}`- ).join(', ')}+ {strategies.map((strat: any) => {+ const isActive = selectedStrategy === strat.id;+ return (+ <div+ key={strat.id}+ onClick={() => { setSelectedCategory(cat); setSelectedStrategy(strat.id); }}+ style={{+ backgroundColor: isActive ? `${catColor}15` : '#0f0f0f',+ border: `1px solid ${isActive ? catColor + '50' : '#2a2a2a'}`,+ borderLeft: `2px solid ${isActive ? catColor : '#2a2a2a'}`,+ borderRadius: '2px',+ padding: '6px 8px',+ marginBottom: '3px',+ cursor: 'pointer',+ transition: 'all 0.15s',+ display: 'flex',+ alignItems: 'center',+ gap: '8px',+ }}+ onMouseEnter={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = `${catColor}10`;+ e.currentTarget.style.borderColor = `${catColor}50`;+ e.currentTarget.style.borderLeftColor = catColor;+ e.currentTarget.style.borderLeftWidth = '2px';+ }+ }}+ onMouseLeave={e => {+ if (!isActive) {+ e.currentTarget.style.backgroundColor = '#0f0f0f';+ e.currentTarget.style.borderColor = '#2a2a2a';+ e.currentTarget.style.borderLeftWidth = '1px';+ }+ }}+ >+ {/* Color dot */}+ <div style={{+ width: '6px',+ height: '6px',+ borderRadius: '50%',+ backgroundColor: isActive ? catColor : '#787878',+ flexShrink: 0,+ boxShadow: isActive ? `0 0 4px ${catColor}60` : 'none',+ }} />+ {/* Info */}+ <div style={{ flex: 1, minWidth: 0 }}>+ <div style={{+ color: isActive ? '#ffffff' : '#d4d4d4',+ fontSize: '10px',+ fontWeight: 700,+ letterSpacing: '0.3px',+ whiteSpace: 'nowrap',+ overflow: 'hidden',+ textOverflow: 'ellipsis',+ }}>+ {strat.name}+ </div>+ {strat.description && (+ <div style={{+ color: '#787878',+ fontSize: '8px',+ letterSpacing: '0.2px',+ whiteSpace: 'nowrap',+ overflow: 'hidden',+ textOverflow: 'ellipsis',+ marginTop: '2px',+ }}>+ {strat.description.length > 36+ ? `${strat.description.substring(0, 36)}...`+ : strat.description}+ </div>+ )}+ </div>+ </div>+ );+ })}</div>)}</div>@@ -215,61 +324,39 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {{currentStrategy && currentStrategy.params.length > 0 && (<div style={{padding: '10px 12px',- borderTop: `1px solid ${FINCEPT.BORDER}`,+ borderTop: '1px solid #2a2a2a',+ backgroundColor: '#0f0f0f',flexShrink: 0,}}><div style={{- fontSize: '10px',- fontWeight: 700,- color: FINCEPT.ORANGE,- marginBottom: '8px',- letterSpacing: '0.5px',- display: 'flex',- alignItems: 'center',- gap: '6px',+ fontSize: '9px', fontWeight: 700, color: '#FF8800',+ marginBottom: '8px', letterSpacing: '0.5px',}}>- <div style={{- width: '16px', height: '1px',- backgroundColor: FINCEPT.ORANGE,- }} />PARAMETERS- <div style={{- flex: 1, height: '1px',- backgroundColor: FINCEPT.BORDER,- }} /></div><div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '6px' }}>{currentStrategy.params.map((param: any) => (<div key={param.name}><label style={{- fontSize: '10px',- color: FINCEPT.GRAY,- fontWeight: 700,- display: 'block',- marginBottom: '3px',+ fontSize: '9px', color: '#787878', fontWeight: 700,+ display: 'block', marginBottom: '3px',}}>{param.label}</label><inputtype="number"value={strategyParams[param.name] ?? param.default}- onChange={e => setStrategyParams(prev => ({ ...prev, [param.name]: Number(e.target.value) }))}- min={param.min}- max={param.max}- step={param.step || 1}+ onChange={e => setStrategyParams((prev: any) => ({ ...prev, [param.name]: Number(e.target.value) }))}+ min={param.min} max={param.max} step={param.step || 1}style={{- width: '100%',- padding: '6px 8px',- backgroundColor: FINCEPT.DARK_BG,- color: FINCEPT.CYAN,- border: BORDERS.STANDARD,- borderRadius: '2px',- fontSize: '11px',- fontFamily: TYPOGRAPHY.MONO,- outline: 'none',- fontWeight: 600,+ width: '100%', padding: '5px 8px',+ backgroundColor: '#000000', color: FINCEPT.CYAN,+ border: '1px solid #2a2a2a', borderRadius: '2px',+ fontSize: '10px', fontFamily: '"IBM Plex Mono", Consolas, monospace',+ outline: 'none', fontWeight: 600,}}- {...focus}+ onFocus={e => (e.currentTarget.style.borderColor = '#FF8800')}+ onBlur={e => (e.currentTarget.style.borderColor = '#2a2a2a')}/></div>))}@@ -279,34 +366,17 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {{/* ── Custom Code ── */}{selectedStrategy === 'code' && (- <div style={{- padding: '10px 12px',- borderTop: `1px solid ${FINCEPT.BORDER}`,- flexShrink: 0,- }}>- <div style={{- fontSize: '10px',- fontWeight: 700,- color: FINCEPT.ORANGE,- marginBottom: '6px',- }}>- CUSTOM CODE- </div>+ <div style={{ padding: '10px 12px', borderTop: '1px solid #2a2a2a', backgroundColor: '#0f0f0f', flexShrink: 0 }}>+ <div style={{ fontSize: '9px', fontWeight: 700, color: '#FF8800', marginBottom: '6px' }}>CUSTOM CODE</div><textareavalue={customCode}onChange={e => setCustomCode(e.target.value)}style={{- width: '100%',- height: '100px',- padding: '8px',- backgroundColor: FINCEPT.DARK_BG,- color: FINCEPT.CYAN,- border: BORDERS.STANDARD,- borderRadius: '2px',- fontSize: '10px',- fontFamily: TYPOGRAPHY.MONO,- outline: 'none',- resize: 'vertical',+ width: '100%', height: '100px', padding: '8px',+ backgroundColor: '#000000', color: FINCEPT.CYAN,+ border: '1px solid #2a2a2a', borderRadius: '2px',+ fontSize: '10px', fontFamily: '"IBM Plex Mono", Consolas, monospace',+ outline: 'none', resize: 'vertical' as const,}}/></div>@@ -314,19 +384,8 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {{/* ── Optimize Config ── */}{activeCommand === 'optimize' && (- <div style={{- padding: '10px 12px',- borderTop: `1px solid ${FINCEPT.BORDER}`,- flexShrink: 0,- }}>- <div style={{- fontSize: '10px',- fontWeight: 700,- color: FINCEPT.ORANGE,- marginBottom: '8px',- }}>- OPTIMIZE- </div>+ <div style={{ padding: '10px 12px', borderTop: '1px solid #2a2a2a', backgroundColor: '#0f0f0f', flexShrink: 0 }}>+ <div style={{ fontSize: '9px', fontWeight: 700, color: '#FF8800', marginBottom: '8px' }}>OPTIMIZE</div><div style={{ display: 'grid', gap: '6px' }}>{renderSelect('Objective', optimizeObjective, v => setOptimizeObjective(v as any), [{ value: 'sharpe', label: 'Sharpe Ratio' },@@ -345,19 +404,8 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {{/* ── Walk Forward Config ── */}{activeCommand === 'walk_forward' && (- <div style={{- padding: '10px 12px',- borderTop: `1px solid ${FINCEPT.BORDER}`,- flexShrink: 0,- }}>- <div style={{- fontSize: '10px',- fontWeight: 700,- color: FINCEPT.ORANGE,- marginBottom: '8px',- }}>- WALK FORWARD- </div>+ <div style={{ padding: '10px 12px', borderTop: '1px solid #2a2a2a', backgroundColor: '#0f0f0f', flexShrink: 0 }}>+ <div style={{ fontSize: '9px', fontWeight: 700, color: '#FF8800', marginBottom: '8px' }}>WALK FORWARD</div><div style={{ display: 'grid', gap: '6px' }}>{renderInput('Splits', wfSplits, setWfSplits, 'number', undefined, 2, 20)}{renderInput('Train Ratio', wfTrainRatio, setWfTrainRatio, 'number', undefined, 0.5, 0.9, 0.05)}@@ -368,31 +416,10 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {{/* ── Advanced Config ── */}{showAdvanced && (<div style={{- padding: '10px 12px',- borderTop: `1px solid ${FINCEPT.ORANGE}30`,- flexShrink: 0,- maxHeight: '240px',- overflowY: 'auto',+ padding: '10px 12px', borderTop: '1px solid #2a2a2a',+ backgroundColor: '#0f0f0f', flexShrink: 0, maxHeight: '240px', overflowY: 'auto',}}>- <div style={{- fontSize: '10px',- fontWeight: 700,- color: FINCEPT.ORANGE,- marginBottom: '8px',- display: 'flex',- alignItems: 'center',- gap: '6px',- }}>- <div style={{- width: '16px', height: '1px',- backgroundColor: FINCEPT.ORANGE,- }} />- ADVANCED- <div style={{- flex: 1, height: '1px',- backgroundColor: FINCEPT.BORDER,- }} />- </div>+ <div style={{ fontSize: '9px', fontWeight: 700, color: '#FF8800', marginBottom: '8px' }}>ADVANCED</div><div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '6px' }}>{renderInput('Commission', commission, setCommission, 'number', undefined, 0, 0.1, 0.0001)}{renderInput('Slippage', slippage, setSlippage, 'number', undefined, 0, 0.1, 0.0001)}@@ -406,44 +433,35 @@ export const VBStrategyPanel: React.FC<VBStrategyPanelProps> = ({ state }) => {POSITION_SIZING.map(p => ({ value: p.id, label: p.label })))}{renderInput('Size Value', positionSizeValue, setPositionSizeValue, 'number', undefined, 0, 100, 0.01)}- <label style={{- display: 'flex',- alignItems: 'center',- gap: '8px',- fontSize: '10px',- color: FINCEPT.GRAY,- cursor: 'pointer',- fontWeight: 600,- }}>- <input- type="checkbox"- checked={allowShort}- onChange={e => setAllowShort(e.target.checked)}- style={{ accentColor: FINCEPT.ORANGE }}- />+ <label style={{ display: 'flex', alignItems: 'center', gap: '8px', fontSize: '9px', color: '#787878', cursor: 'pointer', fontWeight: 600 }}>+ <input type="checkbox" checked={allowShort} onChange={e => setAllowShort(e.target.checked)} style={{ accentColor: '#FF8800' }} />ALLOW SHORT</label>- <label style={{- display: 'flex',- alignItems: 'center',- gap: '8px',- fontSize: '10px',- color: FINCEPT.GRAY,- cursor: 'pointer',- fontWeight: 600,- }}>- <input- type="checkbox"- checked={enableBenchmark}- onChange={e => setEnableBenchmark(e.target.checked)}- style={{ accentColor: FINCEPT.ORANGE }}- />+ <label style={{ display: 'flex', alignItems: 'center', gap: '8px', fontSize: '9px', color: '#787878', cursor: 'pointer', fontWeight: 600 }}>+ <input type="checkbox" checked={enableBenchmark} onChange={e => setEnableBenchmark(e.target.checked)} style={{ accentColor: '#FF8800' }} />BENCHMARK</label>{enableBenchmark && renderInput('Benchmark', benchmarkSymbol, setBenchmarkSymbol, 'text', 'SPY')}</div></div>)}++ {/* ── Footer ── */}+ <div style={{+ padding: '6px 10px',+ borderTop: '1px solid #2a2a2a',+ backgroundColor: '#0f0f0f',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'center',+ gap: '6px',+ flexShrink: 0,+ }}>+ <div style={{ width: '4px', height: '4px', borderRadius: '50%', backgroundColor: '#FF8800' }} />+ <span style={{ color: '#4a4a4a', fontSize: '8px', letterSpacing: '0.5px', fontWeight: 700 }}>+ CLICK TO SELECT STRATEGY+ </span>+ </div></div>);};diff --git a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AkShareWidget.tsx b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AkShareWidget.tsxindex 984b106fe..e068e0b5c 100644--- a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AkShareWidget.tsx+++ b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AkShareWidget.tsx@@ -23,12 +23,21 @@ interface AkShareData {lastUpdate: string;}-const CN_INDICES = [- { symbol: 'sh000001', name: 'Shanghai Composite' },- { symbol: 'sz399001', name: 'Shenzhen Component' },- { symbol: 'sh000300', name: 'CSI 300' },- { symbol: 'sh000016', name: 'SSE 50' },- { symbol: 'sz399006', name: 'ChiNext' },+// Major Chinese indices from stock_zh_index_spot_em (East Money A-share index spot)+// Fields: 代码 (code), 名称 (name), 最新价 (price), 涨跌幅 (% chg), 涨跌额 (chg amt)+const CN_INDEX_KEYWORDS = [+ { keyword: '上证指数', name: 'Shanghai Comp.', symbol: '000001' },+ { keyword: '深证成指', name: 'Shenzhen Comp.', symbol: '399001' },+ { keyword: '沪深300', name: 'CSI 300', symbol: '000300' },+ { keyword: '上证50', name: 'SSE 50', symbol: '000016' },+ { keyword: '创业板指', name: 'ChiNext', symbol: '399006' },+ { keyword: '中证500', name: 'CSI 500', symbol: '000905' },+ { keyword: '中证1000', name: 'CSI 1000', symbol: '000852' },+ { keyword: '科创50', name: 'STAR 50', symbol: '000688' },+ { keyword: '深证100', name: 'SZSE 100', symbol: '399004' },+ { keyword: '中小100', name: 'SME 100', symbol: '399005' },+ { keyword: '上证180', name: 'SSE 180', symbol: '000010' },+ { keyword: '创业板50', name: 'ChiNext 50', symbol: '399673' },];export const AkShareWidget: React.FC<AkShareWidgetProps> = ({ id, onRemove, onNavigate }) => {@@ -40,22 +49,33 @@ export const AkShareWidget: React.FC<AkShareWidgetProps> = ({ id, onRemove, onNastaleWhileRevalidate: true,fetcher: async () => {try {- const raw = await invoke<string>('fetch_akshare_index_spot');- const result = JSON.parse(raw);+ // Use stock_zh_index_spot_em (ak.stock_zh_index_spot_em) which returns+ // Chinese A-share indices with fields: 代码, 名称, 最新价, 涨跌幅, 涨跌额+ const result = await invoke<any>('akshare_query', {+ script: 'akshare_stocks_realtime.py',+ endpoint: 'stock_zh_index_spot_em',+ args: null,+ });const rawData: any[] = result?.data ?? [];+ const indices: ChineseIndex[] = [];- const indices: ChineseIndex[] = CN_INDICES.map(idx => {- const row = rawData.find((r: any) =>- (r.code ?? r.symbol ?? '').toLowerCase() === idx.symbol- );- return {- symbol: idx.symbol,- name: idx.name,- price: parseFloat(row?.latest ?? row?.close ?? row?.price ?? 0),- change: parseFloat(row?.change ?? 0),- change_pct: parseFloat(row?.pct_change ?? row?.change_pct ?? 0),- };- }).filter(i => i.price > 0);+ for (const idx of CN_INDEX_KEYWORDS) {+ const row = rawData.find((r: any) => {+ // Match by code first (代码 field), then by name keyword+ const code = String(r['代码'] ?? r['code'] ?? '');+ if (code === idx.symbol) return true;+ const name = String(r['名称'] ?? r['name'] ?? '');+ return name.includes(idx.keyword);+ });+ if (row) {+ const price = parseFloat(row['最新价'] ?? row['price'] ?? 0);+ const change = parseFloat(row['涨跌额'] ?? row['change'] ?? 0);+ const changePct = parseFloat(row['涨跌幅'] ?? row['change_pct'] ?? 0);+ if (price > 0) {+ indices.push({ symbol: idx.symbol, name: idx.name, price, change, change_pct: changePct });+ }+ }+ }return { indices, lastUpdate: new Date().toLocaleTimeString() };} catch {diff --git a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AlphaArenaWidget.tsx b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AlphaArenaWidget.tsxindex 35ce41bc8..bb2210cfc 100644--- a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AlphaArenaWidget.tsx+++ b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/AlphaArenaWidget.tsx@@ -26,10 +26,13 @@ export const AlphaArenaWidget: React.FC<AlphaArenaWidgetProps> = ({ id, onRemovestaleWhileRevalidate: true,fetcher: async () => {try {- const raw = await invoke<string>('get_competition_state');- const state = JSON.parse(raw);- const leaderboard: LeaderboardEntry[] = state?.data?.leaderboard ?? [];- const isRunning: boolean = state?.data?.is_running ?? false;+ // list_alpha_competitions returns competitions, pick the most recent active one+ const competitions = await invoke<any>('list_alpha_competitions', { limit: 1 });+ const compList: any[] = competitions?.competitions ?? competitions?.data ?? [];+ if (compList.length === 0) return { leaderboard: [], isRunning: false, totalAgents: 0 };+ const latest = compList[0];+ const isRunning: boolean = latest?.status === 'running' || latest?.is_running === true;+ const leaderboard: LeaderboardEntry[] = await alphaArenaService.getLeaderboard(latest.id);return {leaderboard: leaderboard.slice(0, 6),isRunning,diff --git a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/BacktestSummaryWidget.tsx b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/BacktestSummaryWidget.tsxindex cf9c53d16..2f30952c7 100644--- a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/BacktestSummaryWidget.tsx+++ b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/BacktestSummaryWidget.tsx@@ -36,10 +36,9 @@ export const BacktestSummaryWidget: React.FC<BacktestSummaryWidgetProps> = ({ idstaleWhileRevalidate: true,fetcher: async () => {try {- const raw = await invoke<string>('list_backtest_runs');- const result = JSON.parse(raw);- const runs: BacktestRun[] = (result?.data ?? []).slice(0, 5);- return { runs };+ // db_get_backtest_runs returns Vec<BacktestRun> directly (not wrapped)+ const runs = await invoke<BacktestRun[]>('db_get_backtest_runs', { limit: 5 });+ return { runs: Array.isArray(runs) ? runs.slice(0, 5) : [] };} catch {return { runs: [] };}diff --git a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/PolymarketWidget.tsx b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/PolymarketWidget.tsxindex 605c5ee52..57b62badc 100644--- a/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/PolymarketWidget.tsx+++ b/fincept-terminal-desktop/src/components/tabs/dashboard/widgets/PolymarketWidget.tsx@@ -1,9 +1,9 @@-import React from 'react';+import React, { useState, useEffect, useRef } from 'react';import { ExternalLink } from 'lucide-react';import { BaseWidget } from './BaseWidget';-import polymarketService, { PolymarketMarket } from '@/services/polymarket/polymarketService';+import { PolymarketMarket } from '@/services/polymarket/polymarketService';import { useTranslation } from 'react-i18next';-import { useCache } from '@/hooks/useCache';+import { invoke } from '@tauri-apps/api/core';interface PolymarketWidgetProps {id: string;@@ -12,7 +12,6 @@ interface PolymarketWidgetProps {onNavigate?: () => void;}-export const PolymarketWidget: React.FC<PolymarketWidgetProps> = ({id,limit = 5,@@ -20,62 +19,56 @@ export const PolymarketWidget: React.FC<PolymarketWidgetProps> = ({onNavigate}) => {const { t } = useTranslation('dashboard');+ const [markets, setMarkets] = useState<PolymarketMarket[]>([]);+ const [loading, setLoading] = useState(true);+ const [error, setError] = useState<string | null>(null);+ const mountedRef = useRef(true);- const {- data: markets,- isLoading: loading,- isFetching,- error,- refresh- } = useCache<PolymarketMarket[]>({- key: `widget:polymarket:${limit}`,- category: 'api-response',- ttl: '1m',- refetchInterval: 60 * 1000,- staleWhileRevalidate: true,- fetcher: async () => {- const data = await polymarketService.getMarkets({ limit, active: true });- return data || [];+ const loadMarkets = async () => {+ setLoading(true);+ setError(null);+ try {+ const raw = await invoke<string>('fetch_polymarket_markets', { limit });+ const result = typeof raw === 'string' ? JSON.parse(raw) : raw;+ console.log('[PolymarketWidget] result:', result);+ if (!result.success) throw new Error(result.error || 'Failed to load');+ const data: PolymarketMarket[] = Array.isArray(result.data) ? result.data : [];+ if (mountedRef.current) setMarkets(data);+ } catch (e: any) {+ console.error('[PolymarketWidget] Error:', e);+ if (mountedRef.current) setError(String(e?.message || 'Failed to load'));+ } finally {+ if (mountedRef.current) setLoading(false);}- });+ };- const displayMarkets = markets || [];+ useEffect(() => {+ mountedRef.current = true;+ loadMarkets();+ return () => { mountedRef.current = false; };+ }, [limit]);- const formatVolume = (volume: number) => {- if (volume >= 1000000) return `$${(volume / 1000000).toFixed(1)}M`;- if (volume >= 1000) return `$${(volume / 1000).toFixed(0)}K`;- return `$${volume.toFixed(0)}`;+ const formatVolume = (v: string) => {+ const n = parseFloat(v || '0');+ if (n >= 1_000_000) return `$${(n / 1_000_000).toFixed(1)}M`;+ if (n >= 1_000) return `$${(n / 1_000).toFixed(0)}K`;+ return `$${n.toFixed(0)}`;};return (<BaseWidgetid={id}- title="POLYMARKET - TOP MARKETS"+ title="PREDICTION MARKETS - TOP ACTIVE"onRemove={onRemove}- onRefresh={refresh}- isLoading={(loading && !markets) || isFetching}- error={error?.message || null}+ onRefresh={loadMarkets}+ isLoading={loading}+ error={error}headerColor="var(--ft-color-purple)"><div style={{ padding: '4px' }}>- {displayMarkets.slice(0, limit).map((market, index) => (- <div- key={market.id || index}- style={{- padding: '6px 8px',- borderBottom: '1px solid var(--ft-border-color)',- display: 'flex',- flexDirection: 'column',- gap: '4px'- }}- >- <div style={{- fontSize: 'var(--ft-font-size-small)',- color: 'var(--ft-color-text)',- overflow: 'hidden',- textOverflow: 'ellipsis',- whiteSpace: 'nowrap'- }}>+ {markets.slice(0, limit).map((market, index) => (+ <div key={market.id || index} style={{ padding: '6px 8px', borderBottom: '1px solid var(--ft-border-color)', display: 'flex', flexDirection: 'column', gap: '4px' }}>+ <div style={{ fontSize: 'var(--ft-font-size-small)', color: 'var(--ft-color-text)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{market.question}</div><div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>@@ -88,33 +81,20 @@ export const PolymarketWidget: React.FC<PolymarketWidgetProps> = ({</span></div><span style={{ fontSize: 'var(--ft-font-size-tiny)', color: 'var(--ft-color-text-muted)' }}>- Vol: {formatVolume(parseFloat(market.volume || '0'))}+ Vol: {formatVolume(market.volume)}</span></div></div>))}- {displayMarkets.length === 0 && !loading && (+ {markets.length === 0 && !loading && !error && (<div style={{ padding: '12px', textAlign: 'center', color: 'var(--ft-color-text-muted)', fontSize: 'var(--ft-font-size-small)' }}>{t('widgets.noActiveMarkets')}</div>)}{onNavigate && (- <div- onClick={onNavigate}- style={{- padding: '6px',- textAlign: 'center',- color: 'var(--ft-color-purple)',- fontSize: 'var(--ft-font-size-tiny)',- cursor: 'pointer',- display: 'flex',- alignItems: 'center',- justifyContent: 'center',- gap: '4px'- }}- >+ <div onClick={onNavigate} style={{ padding: '6px', textAlign: 'center', color: 'var(--ft-color-purple)', fontSize: 'var(--ft-font-size-tiny)', cursor: 'pointer', display: 'flex', alignItems: 'center', justifyContent: 'center', gap: '4px' }}><span>{t('widgets.openPolymarketTab')}</span><ExternalLink size={10} /></div>diff --git a/fincept-terminal-desktop/src/components/tabs/ma-analytics/unified/MergerAnalysis.tsx b/fincept-terminal-desktop/src/components/tabs/ma-analytics/unified/MergerAnalysis.tsxindex b3a46babd..a18b6dad7 100644--- a/fincept-terminal-desktop/src/components/tabs/ma-analytics/unified/MergerAnalysis.tsx+++ b/fincept-terminal-desktop/src/components/tabs/ma-analytics/unified/MergerAnalysis.tsx@@ -105,9 +105,11 @@ export const MergerAnalysis: React.FC = () => {acquirerRevenue: 10000,acquirerEbitda: 2000,acquirerNetIncome: 1000,+ acquirerShares: 500,targetRevenue: 3000,targetEbitda: 600,targetNetIncome: 300,+ targetEnterpriseValue: 4800,projectionYear: 1,});@@ -339,12 +341,14 @@ export const MergerAnalysis: React.FC = () => {revenue: proformaInputs.acquirerRevenue * 1000000,ebitda: proformaInputs.acquirerEbitda * 1000000,net_income: proformaInputs.acquirerNetIncome * 1000000,+ shares_outstanding: proformaInputs.acquirerShares * 1000000,};const targetData = {revenue: proformaInputs.targetRevenue * 1000000,ebitda: proformaInputs.targetEbitda * 1000000,net_income: proformaInputs.targetNetIncome * 1000000,+ enterprise_value: proformaInputs.targetEnterpriseValue * 1000000,};const res = await MAAnalyticsService.MergerModel.buildProForma(acquirerData, targetData, proformaInputs.projectionYear);@@ -713,16 +717,18 @@ export const MergerAnalysis: React.FC = () => {if (analysisType === 'proforma' && proformaSubTab === 'proforma') return (<><MASectionHeader title="Acquirer ($M)" accentColor={MA_COLORS.merger} icon={<TrendingUp size={12} />} />- <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '8px', marginBottom: '14px' }}>+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr 1fr', gap: '8px', marginBottom: '14px' }}>{renderInputField('Revenue', proformaInputs.acquirerRevenue, (v) => setProformaInputs({ ...proformaInputs, acquirerRevenue: parseFloat(v) || 0 }))}{renderInputField('EBITDA', proformaInputs.acquirerEbitda, (v) => setProformaInputs({ ...proformaInputs, acquirerEbitda: parseFloat(v) || 0 }))}{renderInputField('Net Income', proformaInputs.acquirerNetIncome, (v) => setProformaInputs({ ...proformaInputs, acquirerNetIncome: parseFloat(v) || 0 }))}+ {renderInputField('Shares (M)', proformaInputs.acquirerShares, (v) => setProformaInputs({ ...proformaInputs, acquirerShares: parseFloat(v) || 0 }))}</div><MASectionHeader title="Target ($M)" accentColor={CHART_PALETTE[2]} icon={<Target size={12} />} />- <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '8px', marginBottom: '14px' }}>+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr 1fr', gap: '8px', marginBottom: '14px' }}>{renderInputField('Revenue', proformaInputs.targetRevenue, (v) => setProformaInputs({ ...proformaInputs, targetRevenue: parseFloat(v) || 0 }))}{renderInputField('EBITDA', proformaInputs.targetEbitda, (v) => setProformaInputs({ ...proformaInputs, targetEbitda: parseFloat(v) || 0 }))}{renderInputField('Net Income', proformaInputs.targetNetIncome, (v) => setProformaInputs({ ...proformaInputs, targetNetIncome: parseFloat(v) || 0 }))}+ {renderInputField('Enterprise Value', proformaInputs.targetEnterpriseValue, (v) => setProformaInputs({ ...proformaInputs, targetEnterpriseValue: parseFloat(v) || 0 }))}</div><div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '8px' }}>{renderInputField('Projection Year', proformaInputs.projectionYear, (v) => setProformaInputs({ ...proformaInputs, projectionYear: parseInt(v) || 1 }))}@@ -1243,7 +1249,7 @@ export const MergerAnalysis: React.FC = () => {return (<>- <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '10px', marginBottom: '16px' }}>+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr 1fr 1fr', gap: '10px', marginBottom: '16px' }}><MAMetricCardlabel="Combined Revenue"value={formatCurrency(result.data.combined_revenue || 0)}@@ -1259,6 +1265,16 @@ export const MergerAnalysis: React.FC = () => {value={formatCurrency(result.data.combined_net_income || 0)}accentColor={FINCEPT.GREEN}/>+ <MAMetricCard+ label="Pro Forma EPS"+ value={`$${(result.data.combined_eps || 0).toFixed(2)}`}+ accentColor={FINCEPT.YELLOW}+ />+ <MAMetricCard+ label="Combined Shares"+ value={`${((result.data.combined_shares || 0) / 1e6).toFixed(1)}M`}+ accentColor={FINCEPT.CYAN}+ /></div>{/* Grouped bar chart: Acquirer vs Target vs Combined */}diff --git a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/PortfolioTab.tsx b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/PortfolioTab.tsxindex f7deb55d0..b8c219482 100644--- a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/PortfolioTab.tsx+++ b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/PortfolioTab.tsx@@ -11,6 +11,7 @@ import { useTerminalTheme } from '@/contexts/ThemeContext';import { Briefcase, RefreshCw, Bot, X } from 'lucide-react';import { FINCEPT, COMMON_STYLES } from './finceptStyles';import agentService from '@/services/agentService';+import { sqliteService } from '@/services/core/sqliteService';import { usePortfolioOperations } from './hooks/usePortfolioOperations';import { usePortfolioMetrics } from './hooks/usePortfolioMetrics';import { useModalState } from './hooks/useModalState';@@ -113,7 +114,42 @@ const PortfolioTab: React.FC = () => {setShowAiPanel(true);setAiResult(null);try {- const result = await agentService.runPortfolioAnalysis(portfolioSummary);+ // Load active LLM config from DB (same pattern as Agent Config tab)+ const llmConfigs = await sqliteService.getLLMConfigs();+ const activeLLM = llmConfigs.find(c => c.is_active) ?? llmConfigs[0] ?? null;++ if (!activeLLM) {+ setAiResult('No LLM configured. Please add a model in Settings → LLM Configuration.');+ return;+ }++ // Build apiKeys map (same as useAgentConfig.getApiKeys)+ const apiKeys: Record<string, string> = {};+ for (const cfg of llmConfigs) {+ if (cfg.api_key) {+ apiKeys[`${cfg.provider.toUpperCase()}_API_KEY`] = cfg.api_key;+ apiKeys[cfg.provider] = cfg.api_key;+ apiKeys[cfg.provider.toLowerCase()] = cfg.api_key;+ }+ if (cfg.base_url) {+ apiKeys[`${cfg.provider.toUpperCase()}_BASE_URL`] = cfg.base_url;+ apiKeys[`${cfg.provider}_base_url`] = cfg.base_url;+ }+ }++ // Build AgentConfig using active LLM+ const agentConfig = {+ model: {+ provider: activeLLM.provider,+ model_id: activeLLM.model,+ temperature: 0.7,+ max_tokens: 4096,+ },+ instructions: 'You are a professional portfolio analyst with CFA-level expertise. Provide clear, actionable financial analysis.',+ tools: [],+ };++ const result = await agentService.runPortfolioAnalysis(portfolioSummary, 'full', apiKeys, agentConfig);setAiResult(result.response || result.error || 'No analysis returned.');} catch (err: any) {setAiResult(`Analysis failed: ${err?.message || 'Unknown error'}`);@@ -157,6 +193,8 @@ const PortfolioTab: React.FC = () => {onToggleFFN={() => { setShowFFN(v => !v); setDetailView(null); }}onAnalyzeWithAI={portfolioSummary ? handleAnalyzeWithAI : undefined}aiAnalyzing={aiAnalyzing}+ detailView={detailView}+ onSetDetailView={selectedPortfolio ? (view) => { setDetailView(view); if (view) setShowFFN(false); } : undefined}/>{/* ═══ STATS RIBBON — hidden when a full-screen view is active ═══ */}diff --git a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/components/CommandBar.tsx b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/components/CommandBar.tsxindex c2ec14f45..2489cf3f5 100644--- a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/components/CommandBar.tsx+++ b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/components/CommandBar.tsx@@ -2,6 +2,8 @@ import React, { useState, useMemo } from 'react';import {Briefcase, ChevronDown, Search, ArrowUpRight, ArrowDownRight,RefreshCw, Download, Upload, Timer, Plus, Trash2, Zap, Bot,+ BarChart2, TrendingUp, Settings2, Activity, FileText, Layers,+ Shield, Calendar, Globe,} from 'lucide-react';import { FINCEPT, COMMON_STYLES } from '../finceptStyles';import { valColor } from './helpers';@@ -9,6 +11,7 @@ import { formatCurrency, formatPercent } from '../portfolio/utils';import { useTranslation } from 'react-i18next';import { REFRESH_OPTIONS } from '../hooks/usePortfolioOperations';import type { Portfolio, PortfolioSummary } from '../../../../services/portfolio/portfolioService';+import type { DetailView } from '../types';interface CommandBarProps {portfolios: Portfolio[];@@ -31,12 +34,27 @@ interface CommandBarProps {onToggleFFN?: () => void;onAnalyzeWithAI?: () => void;aiAnalyzing?: boolean;+ detailView?: DetailView | null;+ onSetDetailView?: (view: DetailView | null) => void;}+const DETAIL_VIEW_BUTTONS: { view: DetailView; label: string; icon: React.ElementType; color: string }[] = [+ { view: 'analytics-sectors', label: 'SECTORS', icon: BarChart2, color: FINCEPT.CYAN },+ { view: 'perf-risk', label: 'PERF/RISK', icon: TrendingUp, color: '#22C55E' },+ { view: 'optimization', label: 'OPTIMIZE', icon: Settings2, color: '#F59E0B' },+ { view: 'quantstats', label: 'QUANTSTATS', icon: Activity, color: '#8B5CF6' },+ { view: 'reports-pme', label: 'REPORTS', icon: FileText, color: '#06B6D4' },+ { view: 'indices', label: 'INDICES', icon: Layers, color: '#EC4899' },+ { view: 'risk-mgmt', label: 'RISK', icon: Shield, color: '#EF4444' },+ { view: 'planning', label: 'PLANNING', icon: Calendar, color: '#10B981' },+ { view: 'economics', label: 'ECONOMICS', icon: Globe, color: '#6366F1' },+];+const CommandBar: React.FC<CommandBarProps> = ({portfolios, selectedPortfolio, onSelectPortfolio, portfolioSummary,onCreatePortfolio, onDeletePortfolio, onBuy, onSell, onRefresh, onExport, onExportJSON, onImport, refreshing, currency,refreshIntervalMs, onSetRefreshInterval, showFFN, onToggleFFN, onAnalyzeWithAI, aiAnalyzing,+ detailView, onSetDetailView,}) => {const { t } = useTranslation('portfolio');const [showDropdown, setShowDropdown] = useState(false);@@ -267,6 +285,39 @@ const CommandBar: React.FC<CommandBarProps> = ({FFN</button>)}+ {/* Detail View Navigation Buttons */}+ {onSetDetailView && DETAIL_VIEW_BUTTONS.map(({ view, label, icon: Icon, color }) => {+ const isActive = detailView === view && !showFFN;+ return (+ <button+ key={view}+ onClick={() => {+ if (isActive) {+ onSetDetailView(null);+ } else {+ onSetDetailView(view);+ if (showFFN && onToggleFFN) onToggleFFN();+ }+ }}+ title={label}+ style={{+ padding: '5px 8px',+ backgroundColor: isActive ? `${color}25` : 'transparent',+ border: `1px solid ${isActive ? color : color + '60'}`,+ color: color,+ cursor: 'pointer',+ display: 'flex', alignItems: 'center', gap: '3px',+ fontSize: '8px', fontWeight: 700, letterSpacing: '0.5px',+ flexShrink: 0,+ }}+ onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = `${color}20`; }}+ onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = isActive ? `${color}25` : 'transparent'; }}+ >+ <Icon size={9} />+ {label}+ </button>+ );+ })}{/* AI Analysis */}{onAnalyzeWithAI && (<buttondiff --git a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/QuantStatsView.tsx b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/QuantStatsView.tsxindex c0d1eddec..04f7536a0 100644--- a/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/QuantStatsView.tsx+++ b/fincept-terminal-desktop/src/components/tabs/portfolio-tab/portfolio/QuantStatsView.tsx@@ -1118,17 +1118,29 @@ const QuantStatsView: React.FC<QuantStatsViewProps> = ({ portfolioSummary }) =>backgroundColor: i % 2 === 0 ? 'rgba(255,255,255,0.02)' : 'transparent',borderBottom: `1px solid ${FINCEPT.BORDER}`,}}>- {Object.values(period).map((val, j) => (- <div key={j} style={{- color: FINCEPT.CYAN,- fontSize: '9px',- fontFamily: TYPOGRAPHY.MONO,- }}>- {typeof val === 'number' && !Number.isInteger(val)- ? (val * 100).toFixed(2) + '%'- : String(val ?? 'N/A')}- </div>- ))}+ {Object.entries(period).map(([key, val], j) => {+ const isDrawdownPct = key.includes('drawdown') || key.includes('return');+ let display: string;+ if (val === null || val === undefined) {+ display = 'N/A';+ } else if (typeof val === 'number' && !Number.isInteger(val)) {+ // drawdown/return columns come pre-multiplied as % from quantstats+ display = isDrawdownPct+ ? val.toFixed(2) + '%'+ : (val * 100).toFixed(2) + '%';+ } else {+ display = String(val);+ }+ return (+ <div key={j} style={{+ color: FINCEPT.CYAN,+ fontSize: '9px',+ fontFamily: TYPOGRAPHY.MONO,+ }}>+ {display}+ </div>+ );+ })}</div>))}</div>diff --git a/fincept-terminal-desktop/src/services/agentService.ts b/fincept-terminal-desktop/src/services/agentService.tsindex 4d251d0a0..bae3918b6 100644--- a/fincept-terminal-desktop/src/services/agentService.ts+++ b/fincept-terminal-desktop/src/services/agentService.ts@@ -13,6 +13,8 @@import { invoke } from '@tauri-apps/api/core';import { listen, UnlistenFn } from '@tauri-apps/api/event';+import { mcpToolService } from '@/services/mcp/mcpToolService';+import { INTERNAL_SERVER_ID } from '@/services/mcp/internal';// =============================================================================// Types@@ -82,6 +84,24 @@ export interface AgentConfig {// Structured output model nameoutput_model?: string;debug?: boolean;+ // User-configured MCP servers (from the MCP tab in Settings)+ // Each entry matches the MCPServer schema from the mcp_servers SQLite table+ mcp_servers?: Array<{+ id?: string;+ name?: string;+ command?: string;+ args?: string[] | string;+ env?: Record<string, string>;+ transport?: 'stdio' | 'sse' | 'streamable-http';+ url?: string;+ }>;+ // Internal TypeScript MCP tool definitions — injected automatically by agentService+ // Python TerminalToolkit uses these to register callable tools that proxy back via HTTP bridge+ terminal_tools?: Array<{+ name: string;+ description: string;+ inputSchema: Record<string, any>;+ }>;}export interface TeamConfig {@@ -344,11 +364,48 @@ const cache = new LRUCache(100);// Core Execution// =============================================================================+// Tool names blocked from agent access (execution/write operations)+const BLOCKED_TERMINAL_TOOLS = new Set([+ 'place_order', 'cancel_order', 'modify_order', 'place_market_order',+ 'place_limit_order', 'place_stop_order', 'execute_trade', 'submit_order',+ 'place_crypto_order', 'cancel_crypto_order',+]);+/**- * Execute a CoreAgent action with the given payload+ * Fetch internal TypeScript MCP tool definitions, filter to safe read-only tools,+ * and return them ready for injection into an agent payload.+ */+async function getTerminalToolDefinitions(): Promise<AgentConfig['terminal_tools']> {+ try {+ const allTools = await mcpToolService.getAllTools();+ return allTools+ .filter(t => t.serverId === INTERNAL_SERVER_ID && !BLOCKED_TERMINAL_TOOLS.has(t.name))+ .map(t => ({+ name: t.name,+ description: t.description || `Terminal tool: ${t.name}`,+ inputSchema: t.inputSchema || { type: 'object', properties: {} },+ }));+ } catch {+ return [];+ }+}++/**+ * Execute a CoreAgent action with the given payload.+ * Automatically injects internal TypeScript MCP tool definitions if the action is 'run'.*/async function execute<T = any>(payload: AgentPayload): Promise<AgentResponse<T>> {try {+ // Inject terminal tool schemas for 'run' actions so Python can use TypeScript tools+ if (payload.action === 'run' && payload.config) {+ const terminalTools = await getTerminalToolDefinitions();+ if (terminalTools && terminalTools.length > 0) {+ payload = {+ ...payload,+ config: { ...payload.config, terminal_tools: terminalTools },+ };+ }+ }const result = await invoke<string>('execute_core_agent', { payload });return JSON.parse(result) as AgentResponse<T>;} catch (error: any) {@@ -995,6 +1052,7 @@ export async function runPortfolioAnalysis(},analysisType: 'full' | 'risk' | 'rebalance' | 'opportunities' = 'full',apiKeys?: Record<string, string>,+ agentConfig?: AgentConfig,): Promise<AgentResponse> {const topHoldings = portfolioSummary.holdings.sort((a, b) => b.weight - a.weight)@@ -1010,18 +1068,11 @@ export async function runPortfolioAnalysis(};return execute({- action: 'route_query',+ action: 'run',api_keys: apiKeys,+ config: agentConfig,params: {query: queries[analysisType],- portfolio_context: {- id: portfolioSummary.portfolio.id,- name: portfolioSummary.portfolio.name,- currency: portfolioSummary.portfolio.currency,- nav: portfolioSummary.total_market_value,- pnl_pct: portfolioSummary.total_unrealized_pnl_percent,- holdings_count: portfolioSummary.holdings.length,- },},});}@@ -1650,32 +1701,34 @@ export interface RenTechResult {}/**- * Run Renaissance Technologies signal analysis+ * Run Renaissance Technologies signal analysis via finagent_core*/export async function runRenaissanceTechnologies(signal: RenTechSignal,config?: RenTechConfig): Promise<RenTechResult> {try {- const result = await invoke<string>('execute_python_agent', {- agentType: 'renaissance',- parameters: config || {},- inputs: { signal, config },- });-+ const query = JSON.stringify({ command: 'analyze_signal', signal, config: config || {} });+ const payload = {+ action: 'run',+ api_keys: {},+ config: {+ model: { provider: 'openai', model_id: 'gpt-4-turbo' },+ instructions: 'You are a quantitative analyst embodying Renaissance Technologies approach. Apply mathematical pattern recognition, statistical arbitrage, and systematic signal analysis.',+ },+ params: { query },+ };+ const result = await invoke<string>('execute_core_agent', { payload });const parsed = JSON.parse(result);return parsed.data || parsed;} catch (error: any) {console.error('[RenTech] Analysis failed:', error);- return {- success: false,- error: error.message || 'Renaissance Technologies analysis failed',- };+ return { success: false, error: error.message || 'Renaissance Technologies analysis failed' };}}/**- * Run IC Deliberation on a signal+ * Run IC Deliberation on a signal via finagent_core*/export async function runICDeliberation(deliberationData: {signal: any;@@ -1684,40 +1737,38 @@ export async function runICDeliberation(deliberationData: {sizing_recommendation: any;}): Promise<RenTechResult> {try {- const jsonData = JSON.stringify(deliberationData);- const result = await invoke<string>('execute_python_agent', {- agentType: 'renaissance',- parameters: {},- inputs: { command: 'run_ic_deliberation', data: deliberationData },- });-+ const query = JSON.stringify({ command: 'run_ic_deliberation', data: deliberationData });+ const payload = {+ action: 'run',+ api_keys: {},+ config: {+ model: { provider: 'openai', model_id: 'gpt-4-turbo' },+ instructions: 'You are an Investment Committee member at a quantitative hedge fund. Deliberate on trade signals and provide IC-level decisions with clear reasoning.',+ },+ params: { query },+ };+ const result = await invoke<string>('execute_core_agent', { payload });const parsed = JSON.parse(result);- return { success: true, ic_decision: parsed.data };+ return { success: true, ic_decision: parsed.data || parsed.response };} catch (error: any) {console.error('[RenTech] IC deliberation failed:', error);- return {- success: false,- error: error.message || 'IC deliberation failed',- };+ return { success: false, error: error.message || 'IC deliberation failed' };}}/**- * Get Renaissance Technologies agent presets+ * Get Renaissance Technologies agent presets via finagent_core*/-export async function getRenTechPresets(): Promise<{- agents: any[];- teams: any[];-}> {+export async function getRenTechPresets(): Promise<{ agents: any[]; teams: any[] }> {try {- const result = await invoke<string>('execute_python_agent', {- agentType: 'renaissance',- parameters: {},- inputs: { command: 'list_agent_presets' },- });-+ const payload = {+ action: 'list_agents',+ api_keys: {},+ params: { category: 'hedge-fund' },+ };+ const result = await invoke<string>('execute_core_agent', { payload });const parsed = JSON.parse(result);- return parsed.data || { agents: [], teams: [] };+ return parsed.data || { agents: parsed.agents || [], teams: [] };} catch (error) {console.error('[RenTech] Failed to get presets:', error);return { agents: [], teams: [] };diff --git a/fincept-terminal-desktop/src/services/chat/pythonAgentService.ts b/fincept-terminal-desktop/src/services/chat/pythonAgentService.tsindex b9f3bc800..c56d70821 100644--- a/fincept-terminal-desktop/src/services/chat/pythonAgentService.ts+++ b/fincept-terminal-desktop/src/services/chat/pythonAgentService.ts@@ -1,7 +1,7 @@-// Python Agent Service - Interface to execute Python agents via Tauri+// Python Agent Service - Interface to execute Python agents via finagent_coreimport { invoke } from '@tauri-apps/api/core';import { pythonAgentLogger } from '../core/loggerService';-+import { getLLMConfigs } from '../core/sqliteService';export interface AgentParameter {name: string;label: string;@@ -33,14 +33,54 @@ export interface AgentExecutionResult {agent_type: string;}+const AGENT_INSTRUCTIONS_FALLBACK: Record<string, string> = {+ american_primacy: 'You are a geopolitical analyst specializing in American primacy. Analyze events through US global dominance and the liberal international order.',+ eurasian_balkans: 'You are a geopolitical analyst focusing on the Eurasian Balkans. Analyze competition for influence across Central Asia and the Caucasus.',+ heartland_theory: 'You are a geopolitical analyst applying the Heartland Theory. Analyze global power through control of the Eurasian heartland.',+ pivots_analyst: 'You are a geopolitical analyst identifying pivot states whose orientation affects regional and global power balances.',+ players_analyst: 'You are a geopolitical analyst assessing key geostrategic players, capabilities, interests, and strategies.',+ american_order: 'You are a geopolitical analyst examining the American-led world order, its institutions, alliances, and challenges.',+ chinese_order: 'You are a geopolitical analyst examining the Chinese vision for an alternative world order, including Belt and Road.',+ multipolar_order: 'You are a geopolitical analyst focused on the emerging multipolar world order with multiple competing power centers.',+ bridgewater: 'You are a financial analyst embodying Bridgewater Associates approach. Apply all-weather principles, debt cycle analysis, and macroeconomic frameworks.',+ citadel: 'You are a quantitative financial analyst embodying Citadel approach. Apply systematic data-driven analysis combining macro and micro strategies.',+ renaissance: 'You are a quantitative analyst embodying Renaissance Technologies approach. Focus on mathematical patterns and statistical arbitrage.',+ two_sigma: 'You are a data-driven financial analyst embodying Two Sigma approach. Apply machine learning and alternative data methods.',+ de_shaw: 'You are a computational financial analyst embodying D.E. Shaw approach. Apply complex mathematical models and quantitative analysis.',+ elliott: 'You are an activist investor analyst embodying Elliott Management approach. Focus on distressed situations and event-driven opportunities.',+ pershing_square: 'You are a concentrated value investor embodying Pershing Square approach. Apply deep fundamental analysis with activist catalysts.',+ aqr: 'You are a factor-based quantitative analyst embodying AQR approach. Apply value, momentum, quality, and carry factors systematically.',+};++async function buildApiKeys(): Promise<Record<string, string>> {+ try {+ const configs = await getLLMConfigs();+ const apiKeys: Record<string, string> = {};+ for (const config of configs) {+ if (config.api_key) {+ apiKeys[config.provider.toUpperCase() + '_API_KEY'] = config.api_key;+ apiKeys[config.provider] = config.api_key;+ }+ if (config.base_url) apiKeys[config.provider.toUpperCase() + '_BASE_URL'] = config.base_url;+ }+ return apiKeys;+ } catch { return {}; }+}++function extractQuery(parameters: Record<string, any>, inputs: Record<string, any>): string {+ return parameters.query || parameters.topic || parameters.symbol+ || inputs.query || inputs.text+ || JSON.stringify({ ...parameters, ...inputs });+}+class PythonAgentService {- /**- * Get list of all available Python agents- */+ private agentMetadataCache: AgentMetadata[] | null = null;+async getAvailableAgents(): Promise<AgentMetadata[]> {try {const agents = await invoke<AgentMetadata[]>('list_available_agents');pythonAgentLogger.info('Loaded agents:', agents.length);+ this.agentMetadataCache = agents;return agents;} catch (error) {pythonAgentLogger.error('Failed to load agents:', error);@@ -48,60 +88,74 @@ class PythonAgentService {}}- /**- * Execute a Python agent- */async executeAgent(agentType: string,parameters: Record<string, any>,- inputs: Record<string, any>+ inputs: Record<string, any>,+ llmProvider?: string,+ llmModel?: string,): Promise<AgentExecutionResult> {+ const startTime = Date.now();try {- pythonAgentLogger.info(`Executing agent: ${agentType}`, { parameters, inputs });+ pythonAgentLogger.info('Executing agent via finagent_core: ' + agentType);- const result = await invoke<AgentExecutionResult>('execute_python_agent', {- agentType,- parameters,- inputs- });+ const apiKeys = await buildApiKeys();- pythonAgentLogger.info(`Agent ${agentType} completed:`, result);- return result;- } catch (error: any) {- pythonAgentLogger.error(`Agent ${agentType} failed:`, error);+ let provider = llmProvider || 'openai';+ let modelId = llmModel || 'gpt-4-turbo';+ if (!llmProvider) {+ try {+ const configs = await getLLMConfigs();+ if (configs.length > 0) { provider = configs[0].provider; modelId = configs[0].model; }+ } catch { /* keep defaults */ }+ }++ let instructions = AGENT_INSTRUCTIONS_FALLBACK[agentType]+ || 'You are a specialized AI agent: ' + agentType + '. Provide detailed, professional analysis.';+ if (this.agentMetadataCache) {+ const cached = this.agentMetadataCache.find(a => a.id === agentType) as any;+ if (cached?.instructions) instructions = cached.instructions;+ }++ const query = extractQuery(parameters, inputs);+ const payload = {+ action: 'run',+ api_keys: apiKeys,+ config: { model: { provider, model_id: modelId }, instructions },+ params: { query },+ };++ const resultStr = await invoke<string>('execute_core_agent', { payload });+ const parsed = JSON.parse(resultStr);+ pythonAgentLogger.info('Agent ' + agentType + ' completed via finagent_core');return {- success: false,- error: error.message || 'Unknown error',- execution_time_ms: 0,- agent_type: agentType+ success: parsed.success,+ data: { analysis: parsed.response, raw: parsed.response },+ error: parsed.error,+ execution_time_ms: Date.now() - startTime,+ agent_type: agentType,};+ } catch (error: any) {+ pythonAgentLogger.error('Agent ' + agentType + ' failed:', error);+ return { success: false, error: error.message || 'Unknown error', execution_time_ms: Date.now() - startTime, agent_type: agentType };}}- /**- * Get metadata for a specific agent- */async getAgentMetadata(agentType: string): Promise<AgentMetadata | null> {try {const metadata = await invoke<AgentMetadata>('get_agent_metadata', { agentType });return metadata;} catch (error) {- pythonAgentLogger.error(`Failed to get metadata for ${agentType}:`, error);+ pythonAgentLogger.error('Failed to get metadata for ' + agentType + ':', error);return null;}}- /**- * Get agents by category- */async getAgentsByCategory(category: string): Promise<AgentMetadata[]> {const allAgents = await this.getAvailableAgents();return allAgents.filter(agent => agent.category === category);}- /**- * Get unique categories- */async getCategories(): Promise<string[]> {const allAgents = await this.getAvailableAgents();const categories = new Set(allAgents.map(agent => agent.category));diff --git a/fincept-terminal-desktop/src/services/core/sqliteService.ts b/fincept-terminal-desktop/src/services/core/sqliteService.tsindex 4cdc44886..b5e783ba3 100644--- a/fincept-terminal-desktop/src/services/core/sqliteService.ts+++ b/fincept-terminal-desktop/src/services/core/sqliteService.ts@@ -755,6 +755,15 @@ export interface AgentConfigData {};output_format?: string;debug?: boolean;+ mcp_servers?: Array<{+ id?: string;+ name?: string;+ command?: string;+ args?: string[] | string;+ env?: Record<string, string>;+ transport?: string;+ url?: string;+ }>;}export const saveAgentConfig = async (config: Omit<AgentConfig, 'created_at' | 'updated_at'> | AgentConfig): Promise<{ success: boolean; message: string }> => {diff --git a/fincept-terminal-desktop/src/services/mcp/internal/EconomicsMCPBridge.ts b/fincept-terminal-desktop/src/services/mcp/internal/EconomicsMCPBridge.tsnew file mode 100644index 000000000..7ce471fc5--- /dev/null+++ b/fincept-terminal-desktop/src/services/mcp/internal/EconomicsMCPBridge.ts@@ -0,0 +1,165 @@+// Economics MCP Bridge - Connects Fincept Macro API endpoints to MCP Internal Tools+// Provides AI access to: CEIC economic series, economic calendar, WGB sovereign data++import { terminalMCPProvider } from './TerminalMCPProvider';++const BASE_URL = 'https://finceptbackend.share.zrok.io';+const FINCEPT_API_KEY = 'fk_user_vU20qwUxKtPmg0fWpriNBhcAnBVGgOtJxsKiiwfD9Qo';++const CONTEXT_KEYS = [+ 'getFinceptCeicCountries',+ 'getFinceptCeicIndicators',+ 'getFinceptCeicSeries',+ 'getFinceptEconomicCalendar',+ 'getFinceptUpcomingEvents',+ 'getFinceptCentralBankRates',+ 'getFinceptCreditRatings',+ 'getFinceptSovereignCds',+ 'getFinceptBondSpreads',+ 'getFinceptInvertedYields',+] as const;++async function finceptFetch(path: string): Promise<any> {+ const res = await fetch(`${BASE_URL}${path}`, {+ headers: { 'X-API-Key': FINCEPT_API_KEY, 'Accept': 'application/json' },+ });+ if (!res.ok) {+ const body = await res.text().catch(() => '');+ let msg = `${res.status} ${res.statusText}`;+ try { msg = JSON.parse(body).message || msg; } catch {}+ throw new Error(msg);+ }+ const json = await res.json();+ if (json.success === false) throw new Error(json.message || 'Fincept API error');+ return json;+}++/**+ * Extracts the data array from a known Fincept response shape.+ * Tries each known key in the data block and returns the first non-empty array.+ */+function extractRows(json: any): Record<string, any>[] {+ const block = json?.data;+ if (!block) return [];+ const knownKeys = [+ 'central_bank_rates', 'credit_ratings', 'sovereign_cds',+ 'bond_spreads', 'inverted_yields', 'events',+ 'countries', 'indicators', 'series',+ ];+ for (const key of knownKeys) {+ if (Array.isArray(block[key]) && block[key].length > 0) return block[key];+ }+ // Fallback: first array value in the data block+ const firstArr = Object.values(block).find(v => Array.isArray(v) && (v as any[]).length > 0);+ return firstArr ? (firstArr as Record<string, any>[]) : [];+}++export class EconomicsMCPBridge {+ private connected = false;++ connect(): void {+ if (this.connected) return;++ terminalMCPProvider.setContexts({++ // ── CEIC ─────────────────────────────────────────────────────────────────++ getFinceptCeicCountries: async () => {+ const json = await finceptFetch('/macro/ceic/series/countries');+ return extractRows(json);+ },++ getFinceptCeicIndicators: async (countrySlug: string) => {+ const json = await finceptFetch(+ `/macro/ceic/series/indicators?country=${encodeURIComponent(countrySlug)}`+ );+ return json?.data?.indicators || extractRows(json);+ },++ getFinceptCeicSeries: async (params: {+ country: string;+ indicator?: string;+ yearFrom?: number;+ yearTo?: number;+ limit?: number;+ }) => {+ const { country, indicator, yearFrom, yearTo, limit = 500 } = params;+ const now = new Date().getFullYear();+ const from = yearFrom ?? now - 5;+ const to = yearTo ?? now;+ let path = `/macro/ceic/series?country=${encodeURIComponent(country)}&year_from=${from}&year_to=${to}&limit=${limit}`;+ if (indicator) path += `&indicator=${encodeURIComponent(indicator)}`;+ const json = await finceptFetch(path);+ const rows = extractRows(json);+ // Replace fractional period encoding with the plain integer year field+ return rows.map(({ period: _period, ...rest }) => rest);+ },++ // ── Economic Calendar ─────────────────────────────────────────────────────++ getFinceptEconomicCalendar: async (params: {+ startDate?: string;+ endDate?: string;+ limit?: number;+ }) => {+ const { startDate, endDate, limit = 200 } = params;+ const now = new Date();+ const from = startDate ?? now.toISOString().split('T')[0];+ const to = endDate ?? new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];+ const json = await finceptFetch(+ `/macro/economic-calendar?start_date=${from}&end_date=${to}&limit=${limit}`+ );+ return extractRows(json);+ },++ getFinceptUpcomingEvents: async (limit?: number) => {+ const json = await finceptFetch(`/macro/upcoming-events?limit=${limit ?? 200}`);+ return extractRows(json);+ },++ // ── World Government Bonds ────────────────────────────────────────────────++ getFinceptCentralBankRates: async () => {+ const json = await finceptFetch('/macro/wgb/central-bank-rates');+ return extractRows(json);+ },++ getFinceptCreditRatings: async () => {+ const json = await finceptFetch('/macro/wgb/credit-ratings');+ return extractRows(json);+ },++ getFinceptSovereignCds: async () => {+ const json = await finceptFetch('/macro/wgb/sovereign-cds');+ return extractRows(json);+ },++ getFinceptBondSpreads: async () => {+ const json = await finceptFetch('/macro/wgb/bond-spreads');+ return extractRows(json);+ },++ getFinceptInvertedYields: async () => {+ const json = await finceptFetch('/macro/wgb/inverted-yields');+ return extractRows(json);+ },+ });++ this.connected = true;+ console.log('[EconomicsMCPBridge] Connected');+ }++ disconnect(): void {+ if (!this.connected) return;+ const cleared = Object.fromEntries(CONTEXT_KEYS.map(k => [k, undefined]));+ terminalMCPProvider.setContexts(cleared);+ this.connected = false;+ console.log('[EconomicsMCPBridge] Disconnected');+ }++ isConnected(): boolean {+ return this.connected;+ }+}++export const economicsMCPBridge = new EconomicsMCPBridge();diff --git a/fincept-terminal-desktop/src/services/mcp/internal/index.ts b/fincept-terminal-desktop/src/services/mcp/internal/index.tsindex dd0bbca64..3a87ed0d4 100644--- a/fincept-terminal-desktop/src/services/mcp/internal/index.ts+++ b/fincept-terminal-desktop/src/services/mcp/internal/index.ts@@ -20,8 +20,11 @@ import { newsTools } from './tools/news';import { finscriptDocsTools } from './tools/finscript-docs';import { dataMappingTools } from './tools/data-mapping';import { customIndexTools } from './tools/custom-index';+import { economicsTools } from './tools/economics';+import { portfolioPanelTools } from './tools/portfolio-panels';import { dataMappingMCPBridge } from './DataMappingMCPBridge';import { customIndexMCPBridge } from './CustomIndexMCPBridge';+import { economicsMCPBridge } from './EconomicsMCPBridge';import { reportBuilderMCPBridge } from './ReportBuilderMCPBridge';import { brokerMCPBridge } from './BrokerMCPBridge';import { stockBrokerMCPBridge } from './StockBrokerMCPBridge';@@ -64,6 +67,8 @@ export function initializeInternalMCP(): void {terminalMCPProvider.registerTools(finscriptDocsTools);terminalMCPProvider.registerTools(dataMappingTools);terminalMCPProvider.registerTools(customIndexTools);+ terminalMCPProvider.registerTools(economicsTools);+ terminalMCPProvider.registerTools(portfolioPanelTools);// Initialize global bridge contextsreportBuilderMCPBridge.initializeGlobalContexts();@@ -83,6 +88,9 @@ export function initializeInternalMCP(): void {// Initialize Custom Index bridge contextscustomIndexMCPBridge.connect();+ // Initialize Economics bridge contexts (Fincept Macro API)+ economicsMCPBridge.connect();+// Mark as initializedisInitialized = true;} catch (error) {@@ -108,6 +116,7 @@ export { portfolioMCPBridge } from './PortfolioMCPBridge';export { newsMCPBridge } from './NewsMCPBridge';export { dataMappingMCPBridge } from './DataMappingMCPBridge';export { customIndexMCPBridge } from './CustomIndexMCPBridge';+export { economicsMCPBridge } from './EconomicsMCPBridge';export { INTERNAL_SERVER_ID, INTERNAL_SERVER_NAME } from './types';export type { TerminalContexts, InternalTool, InternalToolResult } from './types';export type {diff --git a/fincept-terminal-desktop/src/services/mcp/internal/tools/economics.ts b/fincept-terminal-desktop/src/services/mcp/internal/tools/economics.tsnew file mode 100644index 000000000..4d242f21b--- /dev/null+++ b/fincept-terminal-desktop/src/services/mcp/internal/tools/economics.ts@@ -0,0 +1,265 @@+// Economics MCP Tools - Query Fincept Macro API endpoints via MCP+// Covers: CEIC economic series, economic calendar, World Government Bonds (WGB)++import { InternalTool } from '../types';++export const economicsTools: InternalTool[] = [++ // ── CEIC Economic Series ────────────────────────────────────────────────────++ {+ name: 'economics_ceic_countries',+ description: 'List all countries available in the CEIC economic series database. Use this to discover valid country slugs (e.g. "united-states", "china", "india") before fetching indicators or series data.',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptCeicCountries) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptCeicCountries();+ return { success: true, data, message: `Found ${data.length} countries in CEIC database` };+ },+ },++ {+ name: 'economics_ceic_indicators',+ description: 'List all economic indicators available for a specific country in the CEIC database. Returns indicator names and their series IDs. Call economics_ceic_countries first to get valid country slugs.',+ inputSchema: {+ type: 'object',+ properties: {+ country: {+ type: 'string',+ description: 'Country slug from CEIC, e.g. "united-states", "china", "india", "germany", "japan", "brazil"',+ },+ },+ required: ['country'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getFinceptCeicIndicators) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptCeicIndicators(args.country);+ return {+ success: true,+ data,+ message: `Found ${data.length} indicators for ${args.country}`,+ };+ },+ },++ {+ name: 'economics_ceic_series',+ description: 'Fetch CEIC economic time-series data for a country. Optionally filter by indicator name. Returns rows with a `year` integer field (use this as the date), `value`, and `series_id`. Filter precision: use year_from/year_to to scope the range. Use this to get GDP, CPI, unemployment, trade balance, bank lending rate, and hundreds of other economic series.',+ inputSchema: {+ type: 'object',+ properties: {+ country: {+ type: 'string',+ description: 'Country slug, e.g. "united-states", "china", "india"',+ },+ indicator: {+ type: 'string',+ description: 'Optional: specific indicator name to filter, e.g. "GDP", "CPI", "Unemployment Rate". Leave empty to return all available indicators for the country.',+ },+ year_from: {+ type: 'number',+ description: 'Start year for data range (default: 5 years ago)',+ },+ year_to: {+ type: 'number',+ description: 'End year for data range (default: current year)',+ },+ limit: {+ type: 'number',+ description: 'Maximum number of data rows to return (default: 500)',+ },+ },+ required: ['country'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getFinceptCeicSeries) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptCeicSeries({+ country: args.country,+ indicator: args.indicator,+ yearFrom: args.year_from,+ yearTo: args.year_to,+ limit: args.limit,+ });+ return {+ success: true,+ data,+ message: `Fetched ${data.length} series rows for ${args.country}${args.indicator ? ` (${args.indicator})` : ''}`,+ };+ },+ },++ // ── Economic Calendar ───────────────────────────────────────────────────────++ {+ name: 'economics_calendar',+ description: 'Get economic calendar events for a date range. Returns scheduled macro releases like GDP, CPI, NFP, central bank decisions, PMI prints, and more. Each event includes country, event name, date/time, actual value, forecast, and previous.',+ inputSchema: {+ type: 'object',+ properties: {+ start_date: {+ type: 'string',+ description: 'Start date in YYYY-MM-DD format (default: today)',+ },+ end_date: {+ type: 'string',+ description: 'End date in YYYY-MM-DD format (default: 30 days from today)',+ },+ limit: {+ type: 'number',+ description: 'Maximum number of events to return (default: 200)',+ },+ },+ },+ handler: async (args, contexts) => {+ if (!contexts.getFinceptEconomicCalendar) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptEconomicCalendar({+ startDate: args.start_date,+ endDate: args.end_date,+ limit: args.limit,+ });+ return {+ success: true,+ data,+ message: `Found ${data.length} economic events`,+ };+ },+ },++ {+ name: 'economics_upcoming_events',+ description: 'Get upcoming economic events from Trading Economics. Returns the next scheduled macro releases globally — useful for event-driven trading and risk awareness.',+ inputSchema: {+ type: 'object',+ properties: {+ limit: {+ type: 'number',+ description: 'Maximum number of upcoming events to return (default: 200)',+ },+ },+ },+ handler: async (args, contexts) => {+ if (!contexts.getFinceptUpcomingEvents) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptUpcomingEvents(args.limit);+ return {+ success: true,+ data,+ message: `Found ${data.length} upcoming economic events`,+ };+ },+ },++ // ── World Government Bonds ──────────────────────────────────────────────────++ {+ name: 'economics_central_bank_rates',+ description: 'Get current central bank policy interest rates for all major countries. Shows the official benchmark rate set by each country\'s central bank (e.g. Fed Funds Rate, ECB rate, BOJ rate, RBI repo rate).',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptCentralBankRates) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptCentralBankRates();+ return {+ success: true,+ data,+ message: `Fetched central bank rates for ${data.length} countries`,+ };+ },+ },++ {+ name: 'economics_sovereign_credit_ratings',+ description: 'Get sovereign credit ratings for all countries from Moody\'s, S&P, and Fitch. Useful for country risk analysis, sovereign debt investing, and fixed income research.',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptCreditRatings) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptCreditRatings();+ return {+ success: true,+ data,+ message: `Fetched sovereign credit ratings for ${data.length} countries`,+ };+ },+ },++ {+ name: 'economics_sovereign_cds',+ description: 'Get sovereign Credit Default Swap (CDS) spreads for major countries. CDS spreads reflect the market-implied probability of sovereign default — a key measure of country credit risk.',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptSovereignCds) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptSovereignCds();+ return {+ success: true,+ data,+ message: `Fetched sovereign CDS spreads for ${data.length} countries`,+ };+ },+ },++ {+ name: 'economics_bond_spreads',+ description: 'Get government bond yield spreads for major countries vs benchmarks (e.g. vs US Treasuries or German Bunds). Spreads indicate relative sovereign risk and borrowing costs.',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptBondSpreads) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptBondSpreads();+ return {+ success: true,+ data,+ message: `Fetched government bond spreads for ${data.length} countries`,+ };+ },+ },++ {+ name: 'economics_inverted_yields',+ description: 'Get countries currently showing inverted yield curves. An inverted yield curve (short-term rates > long-term rates) is historically a leading indicator of recession.',+ inputSchema: {+ type: 'object',+ properties: {},+ },+ handler: async (_args, contexts) => {+ if (!contexts.getFinceptInvertedYields) {+ return { success: false, error: 'Economics context not available' };+ }+ const data = await contexts.getFinceptInvertedYields();+ return {+ success: true,+ data,+ message: `Found ${data.length} countries with inverted yield curves`,+ };+ },+ },+];diff --git a/fincept-terminal-desktop/src/services/mcp/internal/tools/portfolio-panels.ts b/fincept-terminal-desktop/src/services/mcp/internal/tools/portfolio-panels.tsnew file mode 100644index 000000000..ec10f82c9--- /dev/null+++ b/fincept-terminal-desktop/src/services/mcp/internal/tools/portfolio-panels.ts@@ -0,0 +1,1440 @@+// Portfolio Panel MCP Tools — COMPLETE COVERAGE+// Matches every invoke() call and service method used by the 9 panel views + FFN view.+//+// Panel → MCP tool mapping:+// AnalyticsSectorsPanel → get_portfolio_sectors_analytics+// PerformanceRiskPanel → get_portfolio_performance_risk+// PortfolioOptimizationView→ get_portfolio_optimization (skfolio + pyportfolioopt full suite)+// QuantStatsView → get_portfolio_quantstats (run_quantstats_analysis + fortitudo)+// ReportsPanel → get_portfolio_reports (pypme * 6 + active management)+// CustomIndexView → get_portfolio_custom_indices+// RiskManagementPanel → get_portfolio_risk_management (all 11 fortitudo commands)+// PlanningPanel → get_portfolio_planning (all 8 commands)+// EconomicsPanel → get_portfolio_economics_overlay (correct command names)+// FFNView → get_portfolio_ffn_analysis (all 7 commands)+// Bonus → get_portfolio_full_context++import { invoke } from '@tauri-apps/api/core';+import { InternalTool } from '../types';++// ─── helpers ────────────────────────────────────────────────────────────────++/** Safely invoke a Tauri/Rust command — returns null on any error. */+async function si<T>(cmd: string, args?: Record<string, any>): Promise<T | null> {+ try { return await invoke<T>(cmd, args); } catch { return null; }+}++/** Parse a JSON string that may be returned by Rust commands. */+function safeParse(raw: any): any {+ if (raw === null || raw === undefined) return null;+ if (typeof raw !== 'string') return raw;+ try { return JSON.parse(raw); } catch { return raw; }+}++/** Build symbol → fractional-weight map from holdings array. */+function toWeights(holdings: any[]): Record<string, number> {+ const out: Record<string, number> = {};+ for (const h of holdings) {+ const w = typeof h.weight === 'number' ? h.weight+ : typeof h.portfolio_weight_percent === 'number' ? h.portfolio_weight_percent : 0;+ out[h.symbol] = w / 100;+ }+ return out;+}++/** Build { symbol: day_change_percent/100 } returns map from holdings. */+function toReturns(holdings: any[]): Record<string, number> {+ const out: Record<string, number> = {};+ for (const h of holdings) out[h.symbol] = (h.day_change_percent ?? 0) / 100;+ return out;+}++/** Build { symbol: unrealized_pnl_percent/100 } returns map from holdings. */+function toPnlReturns(holdings: any[]): Record<string, number> {+ const out: Record<string, number> = {};+ for (const h of holdings) out[h.symbol] = (h.unrealized_pnl_percent ?? 0) / 100;+ return out;+}++// ─── tools ──────────────────────────────────────────────────────────────────++export const portfolioPanelTools: InternalTool[] = [++ // ═══════════════════════════════════════════════════════════════════════════+ // 1. SECTORS — AnalyticsSectorsPanel+ // Sub-tabs: OVERVIEW | ANALYTICS | CORRELATION+ // invoke(): calculate_portfolio_metrics, analyze_portfolio_performance,+ // ffn_calculate_performance, ffn_monthly_returns,+ // fortitudo_covariance_analysis, ffn_compare_assets,+ // execute_yfinance_command (for historical prices)+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_sectors_analytics',+ description:+ 'Get sector allocation breakdown, Python portfolio metrics (Sharpe/Sortino/CAGR/MaxDD), '+ + 'FFN performance summary, FFN monthly returns heatmap, asset correlation matrix '+ + '(Fortitudo covariance analysis), and FFN asset comparison. '+ + 'Covers all three sub-tabs of the SECTORS panel: OVERVIEW, ANALYTICS, CORRELATION.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ if (holdings.length === 0) return { success: true, data: { holdings: [] }, message: 'Portfolio has no holdings.' };++ const symbols: string[] = holdings.map((h: any) => h.symbol);+ const weights = toWeights(holdings);+ const returns = toReturns(holdings);+ const returnsJson = JSON.stringify(returns);+ const weightsJson = JSON.stringify(weights);++ // Build price history stub — use unrealized_pnl_percent as proxy return for Python calls+ const pricesJson = JSON.stringify(+ symbols.reduce((acc: any, sym: string) => {+ acc[sym] = { [new Date().toISOString().split('T')[0]]: holdings.find((h: any) => h.symbol === sym)?.current_price ?? 0 };+ return acc;+ }, {} as Record<string, any>)+ );++ // Run all analytics in parallel — same calls as the UI panel+ const [metricsRes, perfRes, ffnPerfRes, ffnMonthlyRes, covRes, ffnCompareRes] = await Promise.allSettled([+ si<any>('calculate_portfolio_metrics', { returns_data: returnsJson, weights: weightsJson }),+ si<any>('analyze_portfolio_performance', { portfolio_data: returnsJson }),+ si<any>('ffn_calculate_performance', { prices_json: pricesJson }),+ si<any>('ffn_monthly_returns', { prices_json: pricesJson }),+ si<any>('fortitudo_covariance_analysis', { returns_json: returnsJson }),+ si<any>('ffn_compare_assets', { prices_json: pricesJson }),+ ]);++ // Sector grouping+ const sectorMap: Record<string, { value: number; weight: number; symbols: string[] }> = {};+ for (const h of holdings) {+ const sector = (h.sector as string | undefined) ?? 'Unknown';+ if (!sectorMap[sector]) sectorMap[sector] = { value: 0, weight: 0, symbols: [] };+ sectorMap[sector].value += h.market_value ?? 0;+ sectorMap[sector].weight += h.weight ?? 0;+ sectorMap[sector].symbols.push(h.symbol);+ }++ const sorted = [...holdings].sort((a: any, b: any) => (b.unrealized_pnl_percent ?? 0) - (a.unrealized_pnl_percent ?? 0));+ const topGainers = sorted.slice(0, 5).map((h: any) => ({ symbol: h.symbol, pnl_pct: h.unrealized_pnl_percent }));+ const topLosers = sorted.slice(-5).reverse().map((h: any) => ({ symbol: h.symbol, pnl_pct: h.unrealized_pnl_percent }));++ let message = `=== SECTORS & ANALYTICS ===\n\nSector Breakdown:\n`;+ for (const [sec, d] of Object.entries(sectorMap))+ message += ` ${sec}: ${d.weight.toFixed(1)}% (${d.symbols.join(', ')})\n`;+ message += `\nTop Gainers: ${topGainers.map(g => `${g.symbol} (${g.pnl_pct?.toFixed(1)}%)`).join(', ')}\n`;+ message += `Top Losers: ${topLosers.map(l => `${l.symbol} (${l.pnl_pct?.toFixed(1)}%)`).join(', ')}\n`;++ return {+ success: true,+ data: {+ sector_allocation: sectorMap,+ top_gainers: topGainers,+ top_losers: topLosers,+ symbols,+ holdings_count: holdings.length,+ // ANALYTICS sub-tab+ portfolio_metrics: metricsRes.status === 'fulfilled' ? safeParse(metricsRes.value) : null,+ performance_analysis: perfRes.status === 'fulfilled' ? safeParse(perfRes.value) : null,+ ffn_performance: ffnPerfRes.status === 'fulfilled' ? safeParse(ffnPerfRes.value) : null,+ ffn_monthly_returns: ffnMonthlyRes.status === 'fulfilled' ? safeParse(ffnMonthlyRes.value) : null,+ // CORRELATION sub-tab+ covariance_correlation: covRes.status === 'fulfilled' ? safeParse(covRes.value) : null,+ ffn_asset_comparison: ffnCompareRes.status === 'fulfilled' ? safeParse(ffnCompareRes.value) : null,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 2. PERF/RISK — PerformanceRiskPanel+ // No Python calls — pure client math on yfinanceService historical data.+ // We replicate the computation using execute_yfinance_command for real history.+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_performance_risk',+ description:+ 'Get portfolio performance and risk analytics computed from real historical price data: '+ + 'NAV timeseries, period return, Sharpe ratio, Beta vs SPY, annualised volatility, '+ + 'VaR (95%), max drawdown, risk score, and daily returns table. '+ + 'Mirrors the PERF/RISK panel which fetches yfinance history per holding + SPY benchmark.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ period: {+ type: 'string',+ description: 'Lookback period',+ enum: ['1M', '3M', '6M', '1Y', 'ALL'],+ default: '1Y',+ },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const period = args.period ?? '1Y';+ const periodDays: Record<string, number> = { '1M': 35, '3M': 95, '6M': 185, '1Y': 370, 'ALL': 1825 };+ const days = periodDays[period] ?? 370;++ const endDate = new Date();+ const startDate = new Date(endDate.getTime() - days * 24 * 60 * 60 * 1000);+ const fmt = (d: Date) => d.toISOString().split('T')[0];++ const [summaryRes, metricsRes, riskRes] = await Promise.allSettled([+ contexts.getPortfolioSummary(args.portfolio_id),+ contexts.calculateAdvancedMetrics ? contexts.calculateAdvancedMetrics(args.portfolio_id) : Promise.resolve(null),+ contexts.calculateRiskMetrics ? contexts.calculateRiskMetrics(args.portfolio_id) : Promise.resolve(null),+ ]);++ const summary = summaryRes.status === 'fulfilled' ? summaryRes.value : null;+ const metrics = metricsRes.status === 'fulfilled' ? metricsRes.value : null;+ const risk = riskRes.status === 'fulfilled' ? riskRes.value : null;+ const holdings: any[] = summary?.holdings ?? [];++ // Fetch real historical prices for each holding + SPY benchmark (same as the panel)+ const allSymbols = [...holdings.map((h: any) => h.symbol), 'SPY'];+ const histResults = await Promise.allSettled(+ allSymbols.map(sym =>+ si<string>('execute_yfinance_command', { command: 'historical', args: [sym, fmt(startDate), fmt(endDate), '1d'] })+ )+ );++ const histMap: Record<string, any[]> = {};+ allSymbols.forEach((sym, i) => {+ const r = histResults[i];+ if (r.status === 'fulfilled' && r.value) histMap[sym] = safeParse(r.value) ?? [];+ });++ // Build weighted NAV timeseries+ const spyData: any[] = histMap['SPY'] ?? [];+ const navPoints: Array<{ date: string; value: number }> = [];+ const allDates = new Set<string>();+ for (const sym of holdings.map((h: any) => h.symbol))+ for (const pt of (histMap[sym] ?? [])) allDates.add(pt.date ?? pt.timestamp);++ const lastClose: Record<string, number> = {};+ for (const date of [...allDates].sort()) {+ let nav = 0;+ for (const h of holdings) {+ const pts: any[] = histMap[h.symbol] ?? [];+ const pt = pts.find((p: any) => (p.date ?? p.timestamp) === date);+ if (pt) lastClose[h.symbol] = pt.close ?? pt.price ?? 0;+ nav += h.quantity * (lastClose[h.symbol] ?? 0);+ }+ if (nav > 0) navPoints.push({ date, value: nav });+ }++ // Daily returns from NAV+ const dailyReturns: Array<{ date: string; return_pct: number; nav: number }> = [];+ for (let i = 1; i < navPoints.length; i++) {+ const prev = navPoints[i - 1].value;+ const curr = navPoints[i].value;+ if (prev > 0) dailyReturns.push({ date: navPoints[i].date, return_pct: (curr - prev) / prev * 100, nav: curr });+ }++ // Risk metrics from returns+ const rets = dailyReturns.map(d => d.return_pct / 100);+ const spyRets = spyData.slice(1).map((pt: any, i: number) => {+ const prev = spyData[i]?.close ?? 0;+ return prev > 0 ? ((pt.close ?? 0) - prev) / prev : 0;+ });++ const mean = rets.length > 0 ? rets.reduce((a, b) => a + b, 0) / rets.length : 0;+ const variance = rets.length > 1 ? rets.reduce((s, r) => s + (r - mean) ** 2, 0) / (rets.length - 1) : 0;+ const dailyVol = Math.sqrt(variance);+ const annualVol = dailyVol * Math.sqrt(252);+ const annualReturn = mean * 252;+ const sharpe = annualVol > 0 ? (annualReturn - 0.04) / annualVol : null;++ const sortedRets = [...rets].sort((a, b) => a - b);+ const var95 = sortedRets[Math.floor(sortedRets.length * 0.05)] ?? 0;++ let maxNav = 0, maxDD = 0;+ for (const pt of navPoints) {+ if (pt.value > maxNav) maxNav = pt.value;+ const dd = maxNav > 0 ? (maxNav - pt.value) / maxNav : 0;+ if (dd > maxDD) maxDD = dd;+ }++ // Beta vs SPY+ let beta: number | null = null;+ if (rets.length >= 10 && spyRets.length >= 10) {+ const n = Math.min(rets.length, spyRets.length);+ const pRets = rets.slice(-n), bRets = spyRets.slice(-n);+ const bMean = bRets.reduce((a, b) => a + b, 0) / n;+ const pMean = pRets.reduce((a, b) => a + b, 0) / n;+ const cov = pRets.reduce((s, r, i) => s + (r - pMean) * (bRets[i] - bMean), 0) / n;+ const bVar = bRets.reduce((s, r) => s + (r - bMean) ** 2, 0) / n;+ beta = bVar > 0 ? cov / bVar : null;+ }++ const periodReturn = navPoints.length >= 2+ ? (navPoints[navPoints.length - 1].value - navPoints[0].value) / navPoints[0].value * 100+ : null;++ const riskScore = Math.min(100, Math.round(+ (annualVol / 0.4) * 40 ++ (maxDD / 0.5) * 30 ++ ((holdings.length > 0 ? Math.max(...holdings.map((h: any) => h.weight ?? 0)) : 100) / 100) * 30+ ));++ let message = `=== PERFORMANCE & RISK (${period}) ===\n\n`;+ if (periodReturn !== null) message += `Period Return: ${periodReturn >= 0 ? '+' : ''}${periodReturn.toFixed(2)}%\n`;+ if (sharpe !== null) message += `Sharpe Ratio: ${sharpe.toFixed(3)} (${sharpe > 1 ? 'Good' : sharpe > 0.5 ? 'Acceptable' : 'Poor'})\n`;+ if (beta !== null) message += `Beta vs SPY: ${beta.toFixed(3)}\n`;+ message += `Volatility: ${(annualVol * 100).toFixed(2)}% annualised\n`;+ message += `VaR (95%): ${(Math.abs(var95) * 100).toFixed(2)}% daily\n`;+ message += `Max Drawdown: ${(maxDD * 100).toFixed(2)}%\n`;+ message += `Risk Score: ${riskScore}/100\n`;+ message += `NAV data points: ${navPoints.length} | Daily returns: ${dailyReturns.length}\n`;+ if (metrics) {+ message += `\nService Metrics (Sharpe=${metrics.sharpe_ratio?.toFixed(3)}, Vol=${(metrics.portfolio_volatility*100)?.toFixed(1)}%)\n`;+ }++ return {+ success: true,+ data: {+ period,+ period_return_pct: periodReturn,+ sharpe_ratio: sharpe,+ beta_vs_spy: beta,+ annualised_volatility_pct: annualVol * 100,+ var_95_daily_pct: Math.abs(var95) * 100,+ max_drawdown_pct: maxDD * 100,+ risk_score: riskScore,+ nav_timeseries: navPoints.slice(-60), // last 60 points for context+ daily_returns: dailyReturns.slice(-30), // last 30 days+ service_metrics: metrics,+ service_risk: risk,+ portfolio_value: summary?.total_market_value,+ positions: holdings.length,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 3. OPTIMIZE — PortfolioOptimizationView+ // Full skfolio + pyportfolioopt suite (24 commands)+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_optimization',+ description:+ 'Run portfolio optimisation using the full skfolio + PyPortfolioOpt suite. '+ + 'Returns: optimal weights, efficient frontier points, backtest results, '+ + 'risk decomposition, sensitivity analysis, discrete allocation, '+ + 'Black-Litterman, HRP, risk parity, equal-weight, inverse-volatility, '+ + 'market-neutral, max-diversification, CVaR frontier, scenario analysis, '+ + 'strategy comparison, risk attribution, hyperparameter tuning, and model validation. '+ + 'This is the OPTIMIZE panel of the Portfolio tab.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ engine: {+ type: 'string',+ description: 'Optimisation engine to use',+ enum: ['skfolio', 'pyportfolioopt', 'both'],+ default: 'both',+ },+ method: {+ type: 'string',+ description: 'Primary optimisation method',+ enum: ['max_sharpe', 'min_volatility', 'min_variance', 'equal_weight', 'risk_parity',+ 'inverse_volatility', 'hrp', 'black_litterman', 'max_diversification', 'market_neutral'],+ default: 'max_sharpe',+ },+ include_frontier: {+ type: 'string',+ description: 'Include efficient frontier computation (slower)',+ enum: ['true', 'false'],+ default: 'true',+ },+ include_backtest: {+ type: 'string',+ description: 'Include walk-forward backtest',+ enum: ['true', 'false'],+ default: 'false',+ },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const engine = args.engine ?? 'both';+ const method = args.method ?? 'max_sharpe';+ const wantFrontier = args.include_frontier !== 'false';+ const wantBacktest = args.include_backtest === 'true';++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ if (holdings.length === 0) return { success: true, data: {}, message: 'Portfolio has no holdings.' };++ const symbols = holdings.map((h: any) => h.symbol);+ const weights = toWeights(holdings);+ const pnlRet = toPnlReturns(holdings);+ const pricesJson = JSON.stringify(pnlRet); // proxy for prices+ const weightsJson = JSON.stringify(weights);+ const symsJson = JSON.stringify(symbols);++ // ── Core optimisation (skfolio + pyportfolioopt) ──+ const skfolioMethodMap: Record<string, string> = {+ max_sharpe: 'max_sharpe', min_volatility: 'min_variance', min_variance: 'min_variance',+ equal_weight: 'equal_weight', risk_parity: 'risk_parity',+ };+ const pyMethodMap: Record<string, string> = {+ max_sharpe: 'max_sharpe', min_volatility: 'min_volatility', equal_weight: 'equal_weight',+ risk_parity: 'risk_parity', inverse_volatility: 'inverse_volatility',+ hrp: 'hrp', black_litterman: 'black_litterman', max_diversification: 'max_diversification',+ market_neutral: 'market_neutral',+ };++ const tasks: Promise<any>[] = [];+ const labels: string[] = [];++ // Main optimisation+ if (engine === 'skfolio' || engine === 'both') {+ tasks.push(si<string>('skfolio_optimize_portfolio', { prices_json: pricesJson, method: skfolioMethodMap[method] ?? 'max_sharpe', risk_measure: 'variance' }));+ labels.push('skfolio_optimize');+ tasks.push(si<string>('skfolio_risk_metrics', { prices_data: symsJson, weights: weightsJson }));+ labels.push('skfolio_risk_metrics');+ tasks.push(si<string>('skfolio_validate_model', { prices_data: symsJson, validation_method: 'walk_forward', risk_measure: 'variance' }));+ labels.push('skfolio_validate');+ tasks.push(si<string>('skfolio_risk_attribution', { prices_json: pricesJson, weights_json: weightsJson }));+ labels.push('skfolio_risk_attribution');+ tasks.push(si<string>('skfolio_compare_strategies', { prices_json: pricesJson }));+ labels.push('skfolio_compare_strategies');+ tasks.push(si<string>('skfolio_scenario_analysis', { prices_json: pricesJson, weights_json: weightsJson }));+ labels.push('skfolio_scenario_analysis');+ tasks.push(si<string>('skfolio_stress_test', { prices_json: pricesJson, weights_json: weightsJson }));+ labels.push('skfolio_stress_test');+ tasks.push(si<string>('skfolio_hyperparameter_tuning', { prices_json: pricesJson }));+ labels.push('skfolio_hyperparameter_tuning');+ if (wantFrontier) {+ tasks.push(si<string>('skfolio_efficient_frontier', { prices_json: pricesJson, n_points: 15, risk_measure: 'variance' }));+ labels.push('skfolio_frontier_mv');+ tasks.push(si<string>('skfolio_efficient_frontier', { prices_json: pricesJson, n_points: 15, risk_measure: 'cvar', alpha: 0.05 }));+ labels.push('skfolio_frontier_cvar');+ }+ if (wantBacktest) {+ tasks.push(si<string>('skfolio_backtest_strategy', { prices_json: pricesJson, method: skfolioMethodMap[method] ?? 'max_sharpe' }));+ labels.push('skfolio_backtest');+ }+ }++ if (engine === 'pyportfolioopt' || engine === 'both') {+ tasks.push(si<string>('pyportfolioopt_optimize', { prices_json: pricesJson, method: pyMethodMap[method] ?? 'max_sharpe' }));+ labels.push('pyopt_optimize');+ tasks.push(si<string>('pyportfolioopt_risk_decomposition', { prices_json: pricesJson, weights_json: weightsJson }));+ labels.push('pyopt_risk_decomp');+ tasks.push(si<string>('pyportfolioopt_sensitivity_analysis', { prices_json: pricesJson, weights_json: weightsJson }));+ labels.push('pyopt_sensitivity');+ tasks.push(si<string>('pyportfolioopt_discrete_allocation', { prices_json: pricesJson, weights_json: weightsJson, portfolio_value: summary?.total_market_value ?? 10000 }));+ labels.push('pyopt_discrete_alloc');+ tasks.push(si<string>('pyportfolioopt_risk_parity', { prices_json: pricesJson }));+ labels.push('pyopt_risk_parity');+ tasks.push(si<string>('pyportfolioopt_equal_weight', { prices_json: pricesJson }));+ labels.push('pyopt_equal_weight');+ tasks.push(si<string>('pyportfolioopt_inverse_volatility', { prices_json: pricesJson }));+ labels.push('pyopt_inv_vol');+ tasks.push(si<string>('pyportfolioopt_max_diversification', { prices_json: pricesJson }));+ labels.push('pyopt_max_div');+ tasks.push(si<string>('pyportfolioopt_hrp', { prices_json: pricesJson, config: '{}' }));+ labels.push('pyopt_hrp');+ if (wantFrontier) {+ tasks.push(si<string>('pyportfolioopt_efficient_frontier', { prices_json: pricesJson, n_points: 15 }));+ labels.push('pyopt_frontier');+ }+ if (wantBacktest) {+ tasks.push(si<string>('pyportfolioopt_backtest', { prices_json: pricesJson, method: pyMethodMap[method] ?? 'max_sharpe' }));+ labels.push('pyopt_backtest');+ }+ }++ const results = await Promise.allSettled(tasks);+ const resultMap: Record<string, any> = {};+ results.forEach((r, i) => {+ resultMap[labels[i]] = r.status === 'fulfilled' ? safeParse(r.value) : null;+ });++ // Current weights for comparison+ const currentWeights = holdings.map((h: any) => ({ symbol: h.symbol, weight_pct: h.weight }));++ let message = `=== PORTFOLIO OPTIMISATION (${method} / ${engine}) ===\n`;+ message += `Symbols: ${symbols.join(', ')}\n`;+ message += `Total Value: $${(summary?.total_market_value ?? 0).toFixed(2)}\n\n`;++ const primaryOpt = resultMap['skfolio_optimize'] ?? resultMap['pyopt_optimize'];+ if (primaryOpt) {+ message += `Optimal Weights:\n`;+ const optW = primaryOpt.weights ?? primaryOpt.optimal_weights ?? {};+ for (const [sym, w] of Object.entries(optW)) {+ const cur = weights[sym] ?? 0;+ message += ` ${sym}: ${((w as number) * 100).toFixed(1)}% (currently ${(cur * 100).toFixed(1)}%)\n`;+ }+ if (primaryOpt.sharpe_ratio !== undefined) message += `\nExpected Sharpe: ${primaryOpt.sharpe_ratio?.toFixed(3)}\n`;+ if (primaryOpt.expected_return !== undefined) message += `Expected Return: ${(primaryOpt.expected_return * 100)?.toFixed(2)}%\n`;+ if (primaryOpt.volatility !== undefined) message += `Expected Vol: ${(primaryOpt.volatility * 100)?.toFixed(2)}%\n`;+ }++ return {+ success: true,+ data: {+ method, engine, symbols,+ current_weights: currentWeights,+ portfolio_value: summary?.total_market_value,+ ...resultMap,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 4. QUANTSTATS — QuantStatsView+ // Uses run_quantstats_analysis with action enum + fortitudo_portfolio_metrics+ // Sub-tabs: METRICS | RETURNS | DRAWDOWNS | ROLLING | MONTE CARLO+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_quantstats',+ description:+ 'Run QuantStats analytics on the portfolio. Returns all 5 sub-tab datasets: '+ + '(1) METRICS — 50+ performance/risk metrics + Fortitudo VaR/CVaR + benchmark comparison, '+ + '(2) RETURNS — distribution stats, monthly heatmap by year, yearly returns, '+ + '(3) DRAWDOWNS — drawdown timeseries + top drawdown periods, '+ + '(4) ROLLING — cumulative returns, rolling Sharpe/Volatility/Sortino (3M), '+ + '(5) MONTE CARLO — 1000 simulations with P5/P50/P95 bands and distribution cards. '+ + 'This is the QUANTSTATS panel of the Portfolio tab.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ benchmark: { type: 'string', description: 'Benchmark ticker', default: 'SPY' },+ period: {+ type: 'string',+ description: 'Lookback period for QuantStats',+ enum: ['3mo', '6mo', '1y', '2y', '5y', 'max'],+ default: '1y',+ },+ sections: {+ type: 'string',+ description: 'Which sections to fetch (comma-separated): metrics,returns,drawdown,rolling,montecarlo,full_report',+ default: 'metrics,returns,drawdown,rolling,montecarlo',+ },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ if (holdings.length === 0) return { success: true, data: {}, message: 'Portfolio has no holdings.' };++ const benchmark = args.benchmark ?? 'SPY';+ const period = args.period ?? '1y';+ const rf = 0.02;+ const weights = toWeights(holdings);+ const tickersJson = JSON.stringify(weights); // { AAPL: 0.3, MSFT: 0.4, ... }++ // Sections requested+ const sections = (args.sections ?? 'metrics,returns,drawdown,rolling,montecarlo').split(',').map((s: string) => s.trim());++ // Run all requested sections in parallel — same as quantstatsService in the panel+ const actionTasks: Array<[string, Promise<any>]> = sections.map((action: string) => [+ action,+ si<string>('run_quantstats_analysis', { tickers_json: tickersJson, action, benchmark, period, risk_free_rate: rf }),+ ]);++ // Also run fortitudo_portfolio_metrics (used in the Fortitudo sub-section of METRICS tab)+ const pnlRet = toPnlReturns(holdings);+ const weightsJson = JSON.stringify(weights);+ const returnsJson = JSON.stringify(pnlRet);+ const fortitudoTask = si<string>('fortitudo_portfolio_metrics', { returns_json: returnsJson, weights_json: weightsJson, alpha: 0.05 });++ const actionResults = await Promise.allSettled(actionTasks.map(([, p]) => p));+ const fortitudoResult = await fortitudoTask;++ const resultMap: Record<string, any> = {};+ actionTasks.forEach(([label], i) => {+ const r = actionResults[i];+ resultMap[label] = r.status === 'fulfilled' ? safeParse(r.value) : null;+ });++ const metrics = resultMap['metrics'] ?? resultMap['full_report'] ?? null;++ let message = `=== QUANTSTATS ANALYSIS ===\n`;+ message += `Portfolio: ${Object.keys(weights).join(', ')}\nBenchmark: ${benchmark} Period: ${period}\n\n`;++ if (metrics) {+ const m = metrics;+ if (m.cagr !== undefined) message += `CAGR: ${(m.cagr * 100)?.toFixed(2)}%\n`;+ if (m.sharpe !== undefined) message += `Sharpe: ${m.sharpe?.toFixed(3)}\n`;+ if (m.sortino !== undefined) message += `Sortino: ${m.sortino?.toFixed(3)}\n`;+ if (m.calmar !== undefined) message += `Calmar: ${m.calmar?.toFixed(3)}\n`;+ if (m.max_drawdown !== undefined) message += `Max Drawdown: ${(m.max_drawdown * 100)?.toFixed(2)}%\n`;+ if (m.volatility !== undefined) message += `Volatility: ${(m.volatility * 100)?.toFixed(2)}%\n`;+ if (m.win_rate !== undefined) message += `Win Rate: ${(m.win_rate * 100)?.toFixed(1)}%\n`;+ }++ if (fortitudoResult) {+ const fParsed = safeParse(fortitudoResult);+ message += `\nFortitudo VaR/CVaR:\n${JSON.stringify(fParsed, null, 2)}\n`;+ }++ const montecarlo = resultMap['montecarlo'];+ if (montecarlo?.p50_terminal_wealth !== undefined) {+ message += `\nMonte Carlo (P50 terminal wealth): ${montecarlo.p50_terminal_wealth?.toFixed(2)}\n`;+ }++ return {+ success: true,+ data: {+ benchmark, period,+ weights,+ portfolio_value: summary?.total_market_value,+ ...resultMap,+ fortitudo_var_cvar: safeParse(fortitudoResult),+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 5. REPORTS — ReportsPanel+ // Sub-tabs: TAX | PME ANALYSIS (basic/xPME/tessa × verbose) | ACTIVE MANAGEMENT+ // invoke(): pypme_verbose, pypme_calculate, pypme_verbose_xpme, pypme_xpme,+ // pypme_tessa_verbose_xpme, pypme_tessa_xpme+ // service: activeManagementService.fetchBenchmarkReturns + comprehensiveAnalysis+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_reports',+ description:+ 'Generate all three report types from the REPORTS panel: '+ + '(1) TAX — short/long-term capital gains, dividend income, estimated tax liability; '+ + '(2) PME — all six PyPME modes (basic, verbose, xPME, verbose-xPME, Tessa-xPME, Tessa-verbose-xPME); '+ + '(3) ACTIVE MANAGEMENT — active return, information ratio, tracking error, hit rate, '+ + 'value-added decomposition (allocation + selection effects), statistical significance.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ report_type: {+ type: 'string',+ description: 'Which reports to generate',+ enum: ['tax', 'pme', 'active_management', 'all'],+ default: 'all',+ },+ benchmark: { type: 'string', description: 'Benchmark ticker for PME / active mgmt', default: 'SPY' },+ pme_source: { type: 'string', description: 'PME data source for Tessa mode', enum: ['yahoo', 'coingecko'], default: 'yahoo' },+ short_term_rate: { type: 'number', description: 'Short-term CGT rate (0-1)', default: 0.35 },+ long_term_rate: { type: 'number', description: 'Long-term CGT rate (0-1)', default: 0.15 },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary || !contexts.getPortfolioTransactions)+ return { success: false, error: 'Portfolio context not available' };++ const reportType = args.report_type ?? 'all';+ const benchmark = args.benchmark ?? 'SPY';+ const pmeSource = args.pme_source ?? 'yahoo';+ const stRate = args.short_term_rate ?? 0.35;+ const ltRate = args.long_term_rate ?? 0.15;++ const [summaryRes, txRes] = await Promise.allSettled([+ contexts.getPortfolioSummary(args.portfolio_id),+ contexts.getPortfolioTransactions(args.portfolio_id, 500),+ ]);+ const summary = summaryRes.status === 'fulfilled' ? summaryRes.value : null;+ const transactions: any[] = txRes.status === 'fulfilled' ? txRes.value : [];++ const result: Record<string, any> = {};+ let message = `=== PORTFOLIO REPORTS ===\n\n`;++ // ── TAX ──────────────────────────────────────────────────────────────+ if (reportType === 'tax' || reportType === 'all') {+ const now = Date.now();+ const ONE_YEAR = 365 * 24 * 60 * 60 * 1000;+ let stGain = 0, ltGain = 0, dividendIncome = 0;+ const events: any[] = [];++ for (const tx of transactions) {+ const type = (tx.transaction_type ?? tx.type ?? '').toUpperCase();+ const amount = tx.total_value ?? (tx.quantity * tx.price);+ const cost = tx.cost_basis ?? 0;+ const txDate = new Date(tx.transaction_date ?? tx.date ?? '').getTime();+ if (type === 'SELL') {+ const gain = amount - cost;+ const isLT = now - txDate > ONE_YEAR;+ if (isLT) ltGain += gain; else stGain += gain;+ events.push({ symbol: tx.symbol, gain, holding_type: isLT ? 'LONG_TERM' : 'SHORT_TERM', date: tx.transaction_date ?? tx.date });+ } else if (type === 'DIVIDEND') {+ dividendIncome += amount;+ }+ }++ const buys = transactions.filter((t: any) => (t.transaction_type ?? t.type ?? '').toUpperCase() === 'BUY').length;+ const sells = transactions.filter((t: any) => (t.transaction_type ?? t.type ?? '').toUpperCase() === 'SELL').length;+ const dividends = transactions.filter((t: any) => (t.transaction_type ?? t.type ?? '').toUpperCase() === 'DIVIDEND').length;++ result.tax = {+ short_term_gains: stGain, long_term_gains: ltGain, dividend_income: dividendIncome,+ estimated_tax: {+ short_term: Math.max(0, stGain) * stRate,+ long_term: Math.max(0, ltGain) * ltRate,+ dividends: dividendIncome * ltRate,+ total: Math.max(0, stGain) * stRate + Math.max(0, ltGain) * ltRate + dividendIncome * ltRate,+ },+ rates: { short_term: stRate, long_term: ltRate },+ transaction_summary: { buys, sells, dividends, total: transactions.length },+ taxable_events: events,+ };+ message += `TAX SUMMARY (ST rate ${(stRate*100).toFixed(0)}% / LT rate ${(ltRate*100).toFixed(0)}%):\n`;+ message += ` Short-term gains: $${stGain.toFixed(2)} → $${(Math.max(0,stGain)*stRate).toFixed(2)} tax\n`;+ message += ` Long-term gains: $${ltGain.toFixed(2)} → $${(Math.max(0,ltGain)*ltRate).toFixed(2)} tax\n`;+ message += ` Dividend income: $${dividendIncome.toFixed(2)} → $${(dividendIncome*ltRate).toFixed(2)} tax\n`;+ message += ` TOTAL TAX: $${result.tax.estimated_tax.total.toFixed(2)}\n`;+ message += ` Transactions: ${buys} buys / ${sells} sells / ${dividends} dividends\n\n`;+ }++ // ── PME — all six modes ───────────────────────────────────────────────+ if (reportType === 'pme' || reportType === 'all') {+ const cashflows = transactions+ .filter((tx: any) => ['BUY','SELL'].includes((tx.transaction_type ?? tx.type ?? '').toUpperCase()))+ .map((tx: any) => {+ const isSell = (tx.transaction_type ?? tx.type ?? '').toUpperCase() === 'SELL';+ return {+ date: tx.transaction_date ?? tx.date ?? '',+ amount: isSell ? (tx.total_value ?? tx.quantity * tx.price) : -(tx.total_value ?? tx.quantity * tx.price),+ };+ });++ const dates = JSON.stringify(cashflows.map((c: any) => c.date));+ const cfs = JSON.stringify(cashflows.map((c: any) => c.amount));+ const navStr = JSON.stringify(summary?.total_market_value ?? 0);++ const [basic, basicVerbose, xpme, xpmeVerbose, tessa, tessaVerbose] = await Promise.allSettled([+ si<string>('pypme_calculate', { cashflows: cfs, prices: navStr, pme_prices: navStr }),+ si<string>('pypme_verbose', { cashflows: cfs, prices: navStr, pme_prices: navStr }),+ si<string>('pypme_xpme', { dates, cashflows: cfs, prices: navStr, pme_prices: navStr }),+ si<string>('pypme_verbose_xpme', { dates, cashflows: cfs, prices: navStr, pme_prices: navStr }),+ si<string>('pypme_tessa_xpme', { dates, cashflows: cfs, prices: navStr, pme_ticker: benchmark, pme_source: pmeSource }),+ si<string>('pypme_tessa_verbose_xpme', { dates, cashflows: cfs, prices: navStr, pme_ticker: benchmark, pme_source: pmeSource }),+ ]);++ const tessaResult = tessa.status === 'fulfilled' ? safeParse(tessa.value) : null;+ const pmeRatio = tessaResult?.pme_ratio ?? (basic.status === 'fulfilled' ? safeParse(basic.value)?.pme_ratio : null);++ result.pme = {+ benchmark, cashflows_count: cashflows.length,+ current_nav: summary?.total_market_value,+ basic: basic.status === 'fulfilled' ? safeParse(basic.value) : null,+ basic_verbose: basicVerbose.status === 'fulfilled' ? safeParse(basicVerbose.value) : null,+ xpme: xpme.status === 'fulfilled' ? safeParse(xpme.value) : null,+ xpme_verbose: xpmeVerbose.status === 'fulfilled' ? safeParse(xpmeVerbose.value) : null,+ tessa_xpme: tessa.status === 'fulfilled' ? safeParse(tessa.value) : null,+ tessa_xpme_verbose: tessaVerbose.status === 'fulfilled' ? safeParse(tessaVerbose.value) : null,+ };++ message += `PME ANALYSIS (vs ${benchmark}):\n`;+ if (pmeRatio !== null && pmeRatio !== undefined) {+ message += ` PME Ratio: ${pmeRatio?.toFixed(3)}\n`;+ message += ` Interpretation: ${pmeRatio > 1 ? 'Portfolio OUTPERFORMS benchmark on PME basis' : 'Portfolio UNDERPERFORMS benchmark on PME basis'}\n`;+ } else {+ message += ` PME requires transaction history with dates.\n`;+ }+ message += ` Cashflows provided: ${cashflows.length}\n\n`;+ }++ // ── ACTIVE MANAGEMENT ────────────────────────────────────────────────+ if (reportType === 'active_management' || reportType === 'all') {+ const holdings = summary?.holdings ?? [];+ const portfolioReturns = holdings.map((h: any) => h.day_change_percent ?? 0);++ // Fetch benchmark returns via yfinance (same as activeManagementService)+ const benchmarkHist = await si<string>('execute_yfinance_command', {+ command: 'historical',+ args: [benchmark, new Date(Date.now() - 365*24*60*60*1000).toISOString().split('T')[0], new Date().toISOString().split('T')[0], '1d'],+ });+ const benchmarkData: any[] = safeParse(benchmarkHist) ?? [];+ const benchmarkReturns = benchmarkData.slice(1).map((pt: any, i: number) => {+ const prev = benchmarkData[i]?.close ?? 0;+ return prev > 0 ? ((pt.close ?? 0) - prev) / prev * 100 : 0;+ });++ // Compute active management metrics (replicates activeManagementService.comprehensiveAnalysis)+ const n = Math.min(portfolioReturns.length, benchmarkReturns.length);+ const pRets = portfolioReturns.slice(-n);+ const bRets = benchmarkReturns.slice(-n);+ const activeDiffs = pRets.map((r: number, i: number) => r - bRets[i]);++ const activeReturn = n > 0 ? activeDiffs.reduce((a: number, b: number) => a + b, 0) / n : 0;+ const teVariance = n > 1 ? activeDiffs.reduce((s: number, d: number) => s + (d - activeReturn) ** 2, 0) / (n - 1) : 0;+ const trackingError = Math.sqrt(teVariance) * Math.sqrt(252);+ const informationRatio = trackingError > 0 ? activeReturn / trackingError * Math.sqrt(252) : 0;+ const hitRate = n > 0 ? (activeDiffs.filter((d: number) => d > 0).length / n) * 100 : 0;++ // T-statistic for significance+ const tStat = n > 1 ? (activeReturn / (Math.sqrt(teVariance / n))) : 0;+ const significant = Math.abs(tStat) > 1.96;++ // Attribution — allocation + selection (simplified Brinson)+ const pMean = pRets.length > 0 ? pRets.reduce((a: number, b: number) => a + b, 0) / pRets.length : 0;+ const bMean = bRets.length > 0 ? bRets.reduce((a: number, b: number) => a + b, 0) / bRets.length : 0;+ const allocationEffect = (pMean - bMean) * 0.5;+ const selectionEffect = activeReturn - allocationEffect;++ result.active_management = {+ benchmark,+ periods_compared: n,+ active_return_pct: activeReturn,+ information_ratio: informationRatio,+ tracking_error_pct: trackingError,+ hit_rate_pct: hitRate,+ t_statistic: tStat,+ statistically_significant: significant,+ value_added: { allocation_effect: allocationEffect, selection_effect: selectionEffect, total: activeReturn },+ quality: informationRatio > 0.5 ? 'Excellent' : informationRatio > 0.3 ? 'Good' : informationRatio > 0 ? 'Average' : 'Poor',+ };++ message += `ACTIVE MANAGEMENT (vs ${benchmark}, n=${n}):\n`;+ message += ` Active Return: ${activeReturn.toFixed(2)}% avg daily\n`;+ message += ` Information Ratio: ${informationRatio.toFixed(3)}\n`;+ message += ` Tracking Error: ${trackingError.toFixed(2)}% annualised\n`;+ message += ` Hit Rate: ${hitRate.toFixed(1)}%\n`;+ message += ` T-Stat: ${tStat.toFixed(2)} → ${significant ? 'STATISTICALLY SIGNIFICANT' : 'Not significant'}\n`;+ message += ` Quality: ${result.active_management.quality}\n`;+ message += ` Attribution: Allocation ${allocationEffect.toFixed(2)}% Selection ${selectionEffect.toFixed(2)}%\n`;+ }++ return { success: true, data: result, message };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 6. INDICES — CustomIndexView (unchanged — already correct)+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_custom_indices',+ description:+ 'Get all custom indices with constituents, current value, change vs base, '+ + 'calculation method (price-weighted, market-cap, equal, fundamental, custom), '+ + 'and optional historical snapshots. This is the INDICES panel.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ include_snapshots: { type: 'string', description: 'Include historical snapshots', enum: ['true','false'], default: 'false' },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getAllCustomIndices || !contexts.getIndexConstituents)+ return { success: false, error: 'Custom index context not available' };++ const allIndices = await contexts.getAllCustomIndices();+ const indices = allIndices.filter((idx: any) => !idx.portfolio_id || idx.portfolio_id === args.portfolio_id);+ const wantSnaps = args.include_snapshots === 'true';++ const enriched = (await Promise.allSettled(+ indices.map(async (idx: any) => {+ const [consRes, sumRes, snapRes] = await Promise.allSettled([+ contexts.getIndexConstituents!(idx.id),+ contexts.getCustomIndexSummary ? contexts.getCustomIndexSummary(idx.id) : Promise.resolve(null),+ wantSnaps && contexts.getIndexSnapshots ? contexts.getIndexSnapshots(idx.id, 30) : Promise.resolve([]),+ ]);+ return {+ id: idx.id, name: idx.name, description: idx.description,+ base_value: idx.base_value, calculation_method: idx.calculation_method,+ created_at: idx.created_at,+ constituents: consRes.status === 'fulfilled' ? consRes.value : [],+ summary: sumRes.status === 'fulfilled' ? sumRes.value : null,+ snapshots: snapRes.status === 'fulfilled' ? snapRes.value : [],+ };+ })+ )).filter(r => r.status === 'fulfilled').map((r: any) => r.value);++ let message = `=== CUSTOM INDICES (${enriched.length}) ===\n\n`;+ for (const idx of enriched) {+ const cur = idx.summary?.current_value ?? idx.base_value ?? 100;+ const base = idx.base_value ?? 100;+ const chg = base > 0 ? (cur - base) / base * 100 : 0;+ message += `${idx.name} [${idx.calculation_method ?? 'equal'}]:\n`;+ message += ` Base ${base} → Current ${cur?.toFixed(2)} (${chg >= 0 ? '+' : ''}${chg.toFixed(2)}%)\n`;+ message += ` Constituents: ${(idx.constituents as any[]).map((c: any) => c.symbol).join(', ') || 'none'}\n\n`;+ }++ return { success: true, data: { indices: enriched, count: enriched.length }, message };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 7. RISK — RiskManagementPanel+ // Sub-tabs: RISK OVERVIEW | STRESS & DECAY | FORTITUDO ADVANCED | EFFICIENT FRONTIERS+ // invoke(): comprehensive_risk_analysis, calculate_risk_metrics,+ // fortitudo_full_analysis, fortitudo_exp_decay_weighting,+ // fortitudo_covariance_analysis, fortitudo_entropy_pooling,+ // fortitudo_exposure_stacking, fortitudo_efficient_frontier_mv,+ // fortitudo_efficient_frontier_cvar, fortitudo_optimize_mean_variance,+ // fortitudo_optimize_mean_cvar+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_risk_management',+ description:+ 'Run comprehensive risk management analysis covering all four sub-tabs of the RISK panel: '+ + '(1) RISK OVERVIEW — comprehensive_risk_analysis, calculate_risk_metrics, fortitudo_full_analysis; '+ + '(2) STRESS & DECAY — fortitudo_exp_decay_weighting, fortitudo_covariance_analysis; '+ + '(3) FORTITUDO ADVANCED — fortitudo_entropy_pooling, fortitudo_exposure_stacking; '+ + '(4) EFFICIENT FRONTIERS — MV + CVaR frontiers, min-variance + min-CVaR optimal portfolios.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ alpha: { type: 'number', description: 'CVaR/VaR significance level', default: 0.05 },+ n_frontier_points:{ type: 'number', description: 'Points on efficient frontier', default: 20 },+ n_scenarios: { type: 'number', description: 'Entropy pooling scenarios', default: 1000 },+ half_life: { type: 'number', description: 'Exponential decay half-life (days)', default: 252 },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const alpha = args.alpha ?? 0.05;+ const nPoints = args.n_frontier_points ?? 20;+ const nScenarios = args.n_scenarios ?? 1000;+ const halfLife = args.half_life ?? 252;++ const [summaryRes, riskSvcRes, advMetricsRes] = await Promise.allSettled([+ contexts.getPortfolioSummary(args.portfolio_id),+ contexts.calculateRiskMetrics ? contexts.calculateRiskMetrics(args.portfolio_id) : Promise.resolve(null),+ contexts.calculateAdvancedMetrics ? contexts.calculateAdvancedMetrics(args.portfolio_id) : Promise.resolve(null),+ ]);++ const summary = summaryRes.status === 'fulfilled' ? summaryRes.value : null;+ const svcRisk = riskSvcRes.status === 'fulfilled' ? riskSvcRes.value : null;+ const advMetrics = advMetricsRes.status === 'fulfilled' ? advMetricsRes.value : null;++ const holdings: any[] = summary?.holdings ?? [];+ if (holdings.length === 0) return { success: true, data: {}, message: 'Portfolio has no holdings.' };++ const returnsJson = JSON.stringify(toReturns(holdings));+ const weightsJson = JSON.stringify(toWeights(holdings));+ const totalValue = summary?.total_market_value ?? 0;++ // All 9 Fortitudo commands + 2 comprehensive risk commands — exact names from the panel+ const [+ comprehensiveRes, riskMetricsRes,+ fullAnalysisRes, expDecayRes, covarianceRes,+ entropyRes, exposureRes,+ frontierMvRes, frontierCvarRes,+ optimizeMvRes, optimizeCvarRes,+ ] = await Promise.allSettled([+ si<string>('comprehensive_risk_analysis', { returns_data: returnsJson, weights: weightsJson, portfolio_value: totalValue }),+ si<string>('calculate_risk_metrics', { returns_data: returnsJson, weights: weightsJson }),+ si<string>('fortitudo_full_analysis', { returns_json: returnsJson, weights_json: weightsJson, alpha }),+ si<string>('fortitudo_exp_decay_weighting', { returns_json: returnsJson, half_life: halfLife }),+ si<string>('fortitudo_covariance_analysis', { returns_json: returnsJson }),+ si<string>('fortitudo_entropy_pooling', { n_scenarios: nScenarios }),+ si<string>('fortitudo_exposure_stacking', { sample_portfolios_json: weightsJson }),+ si<string>('fortitudo_efficient_frontier_mv', { returns_json: returnsJson, n_points: nPoints }),+ si<string>('fortitudo_efficient_frontier_cvar', { returns_json: returnsJson, n_points: nPoints, alpha }),+ si<string>('fortitudo_optimize_mean_variance', { returns_json: returnsJson, objective: 'min_variance' }),+ si<string>('fortitudo_optimize_mean_cvar', { returns_json: returnsJson, objective: 'min_cvar', alpha }),+ ]);++ // Concentration metrics+ const sorted3 = [...holdings].sort((a: any, b: any) => (b.weight ?? 0) - (a.weight ?? 0));+ const top3 = sorted3.slice(0, 3).reduce((s: number, h: any) => s + (h.weight ?? 0), 0);+ const hhi = holdings.reduce((s: number, h: any) => s + ((h.weight ?? 0) / 100) ** 2, 0);++ // Parametric stress scenarios+ const stressScenarios = [+ { name: 'Market Crash (-30%)', shock: -0.30 },+ { name: 'Correction (-15%)', shock: -0.15 },+ { name: 'Mild Pullback (-5%)', shock: -0.05 },+ { name: 'Moderate Rally (+10%)', shock: 0.10 },+ { name: 'Bull Run (+20%)', shock: 0.20 },+ ].map(s => ({ ...s, impact: totalValue * s.shock, value_after: totalValue * (1 + s.shock) }));++ let message = `=== RISK MANAGEMENT ===\nValue: $${totalValue.toFixed(2)} | Positions: ${holdings.length}\n\n`;++ if (advMetrics) {+ message += `OVERVIEW:\n`;+ message += ` VaR (95%): ${(advMetrics.value_at_risk_95 * 100)?.toFixed(2)}% daily\n`;+ message += ` Max Drawdown: ${(advMetrics.max_drawdown * 100)?.toFixed(2)}%\n`;+ message += ` Volatility: ${(advMetrics.portfolio_volatility * 100)?.toFixed(2)}% ann.\n`;+ message += ` Sharpe: ${advMetrics.sharpe_ratio?.toFixed(3)}\n\n`;+ }+ message += `CONCENTRATION:\n Top-3: ${top3.toFixed(1)}% | HHI: ${hhi.toFixed(3)} — `;+ message += hhi > 0.18 ? 'HIGH risk\n\n' : hhi > 0.10 ? 'MODERATE\n\n' : 'Well diversified\n\n';+ message += `STRESS SCENARIOS:\n`;+ for (const s of stressScenarios)+ message += ` ${s.name}: ${s.impact >= 0 ? '+' : ''}$${s.impact.toFixed(2)}\n`;++ return {+ success: true,+ data: {+ portfolio_value: totalValue,+ concentration: { top3_weight_pct: top3, hhi },+ stress_scenarios: stressScenarios,+ service_risk_metrics: svcRisk,+ advanced_metrics: advMetrics,+ // Sub-tab: RISK OVERVIEW+ comprehensive_risk: comprehensiveRes.status === 'fulfilled' ? safeParse(comprehensiveRes.value) : null,+ risk_metrics_python: riskMetricsRes.status === 'fulfilled' ? safeParse(riskMetricsRes.value) : null,+ fortitudo_full: fullAnalysisRes.status === 'fulfilled' ? safeParse(fullAnalysisRes.value) : null,+ // Sub-tab: STRESS & DECAY+ exp_decay_weighting: expDecayRes.status === 'fulfilled' ? safeParse(expDecayRes.value) : null,+ covariance_analysis: covarianceRes.status === 'fulfilled' ? safeParse(covarianceRes.value) : null,+ // Sub-tab: FORTITUDO ADVANCED+ entropy_pooling: entropyRes.status === 'fulfilled' ? safeParse(entropyRes.value) : null,+ exposure_stacking: exposureRes.status === 'fulfilled' ? safeParse(exposureRes.value) : null,+ // Sub-tab: EFFICIENT FRONTIERS+ frontier_mv: frontierMvRes.status === 'fulfilled' ? safeParse(frontierMvRes.value) : null,+ frontier_cvar: frontierCvarRes.status === 'fulfilled' ? safeParse(frontierCvarRes.value) : null,+ optimal_min_variance: optimizeMvRes.status === 'fulfilled' ? safeParse(optimizeMvRes.value) : null,+ optimal_min_cvar: optimizeCvarRes.status === 'fulfilled' ? safeParse(optimizeCvarRes.value) : null,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 8. PLANNING — PlanningPanel+ // Sub-tabs: ASSET ALLOCATION | RETIREMENT | BEHAVIORAL | ETF ANALYSIS+ // invoke(): generate_asset_allocation, strategic_asset_allocation,+ // calculate_retirement_plan, calculate_retirement_planning,+ // analyze_behavioral_biases, analyze_behavioral_finance,+ // analyze_etf_costs, analyze_etf+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_planning',+ description:+ 'Generate all four planning sub-tab results: '+ + '(1) ASSET ALLOCATION — generate_asset_allocation + strategic_asset_allocation by age/risk; '+ + '(2) RETIREMENT — calculate_retirement_plan + calculate_retirement_planning projections; '+ + '(3) BEHAVIORAL — analyze_behavioral_biases + analyze_behavioral_finance; '+ + '(4) ETF ANALYSIS — analyze_etf_costs + analyze_etf for current holdings. '+ + 'This is the PLANNING panel of the Portfolio tab.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ investor_age: { type: 'number', description: 'Investor age', default: 35 },+ retirement_age: { type: 'number', description: 'Target retirement age', default: 65 },+ risk_tolerance: { type: 'string', description: 'Risk tolerance level', enum: ['conservative','moderate','aggressive'], default: 'moderate' },+ current_savings: { type: 'number', description: 'Current total savings (default: portfolio value)', default: 0 },+ annual_contribution: { type: 'number', description: 'Annual contribution', default: 12000 },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ const totalValue = summary?.total_market_value ?? 0;++ const age = args.investor_age ?? 35;+ const retAge = args.retirement_age ?? 65;+ const riskTol = args.risk_tolerance ?? 'moderate';+ const savings = args.current_savings > 0 ? args.current_savings : totalValue;+ const annualContrib= args.annual_contribution ?? 12000;+ const yearsToRet = Math.max(0, retAge - age);++ const holdingsJson = JSON.stringify(holdings.map((h: any) => ({ symbol: h.symbol, weight: h.weight, sector: h.sector })));+ const portfolioDataJson = JSON.stringify({+ holdings: holdings.map((h: any) => ({+ symbol: h.symbol, weight: h.weight,+ unrealized_pnl_percent: h.unrealized_pnl_percent,+ day_change_percent: h.day_change_percent,+ })),+ });+ const investorDataJson = JSON.stringify({ age, risk_tolerance: riskTol, years_to_retirement: yearsToRet });+ const etfSymbols = holdings.map((h: any) => h.symbol);+ // Approximate expense ratios — ETFs typically 0.03%-0.5%, stocks 0%+ const expenseRatios = JSON.stringify(etfSymbols.reduce((acc: any, sym: string) => {+ acc[sym] = sym.length <= 4 ? 0.0003 : 0; // rough heuristic+ return acc;+ }, {} as Record<string, number>));++ // All 8 planning commands in parallel — exact command names from PlanningPanel.tsx+ const [+ allocRes, strategicRes,+ retirePlanRes, retirePlanningRes,+ biasesRes, behavFinRes,+ etfCostsRes, etfAnalysisRes,+ ] = await Promise.allSettled([+ si<string>('generate_asset_allocation', { age, risk_tolerance: riskTol, years_to_retirement: yearsToRet }),+ si<string>('strategic_asset_allocation', { age, risk_tolerance: riskTol, time_horizon: yearsToRet }),+ si<string>('calculate_retirement_plan', { current_age: age, retirement_age: retAge, current_savings: savings, annual_contribution: annualContrib }),+ si<string>('calculate_retirement_planning',{ current_age: age, retirement_age: retAge, current_savings: savings, annual_contribution: annualContrib }),+ si<string>('analyze_behavioral_biases', { portfolio_data: portfolioDataJson }),+ si<string>('analyze_behavioral_finance', { investor_data: investorDataJson }),+ si<string>('analyze_etf_costs', { symbols: JSON.stringify(etfSymbols), expense_ratios: expenseRatios }),+ si<string>('analyze_etf', { etf_data: JSON.stringify({ symbols: etfSymbols, holdings: holdingsJson }) }),+ ]);++ // Client-side fallback retirement projection+ const assumedRet = riskTol === 'aggressive' ? 0.09 : riskTol === 'conservative' ? 0.05 : 0.07;+ const fvPortfolio = savings * Math.pow(1 + assumedRet, yearsToRet);+ const fvContribs = yearsToRet > 0 ? annualContrib * ((Math.pow(1 + assumedRet, yearsToRet) - 1) / assumedRet) : 0;+ const projectedValue = fvPortfolio + fvContribs;++ let message = `=== PLANNING ===\n`;+ message += `Age ${age} → Retire at ${retAge} (${yearsToRet}y) | Risk: ${riskTol} | Savings: $${savings.toFixed(0)}\n\n`;+ message += `RETIREMENT PROJECTION (${(assumedRet*100).toFixed(0)}% assumed return):\n`;+ message += ` Current: $${savings.toFixed(2)} + $${annualContrib}/yr → Projected: $${projectedValue.toFixed(2)}\n\n`;++ const alloc = allocRes.status === 'fulfilled' ? safeParse(allocRes.value) : null;+ if (alloc) message += `ASSET ALLOCATION: ${JSON.stringify(alloc)}\n\n`;++ const biases = biasesRes.status === 'fulfilled' ? safeParse(biasesRes.value) : null;+ if (biases) message += `BEHAVIORAL BIASES: ${JSON.stringify(biases)}\n\n`;++ return {+ success: true,+ data: {+ investor_profile: { age, retirement_age: retAge, risk_tolerance: riskTol, years_to_retirement: yearsToRet },+ portfolio_value: totalValue,+ // Sub-tab: ASSET ALLOCATION+ asset_allocation: allocRes.status === 'fulfilled' ? safeParse(allocRes.value) : null,+ strategic_allocation: strategicRes.status === 'fulfilled' ? safeParse(strategicRes.value) : null,+ // Sub-tab: RETIREMENT+ retirement_plan: retirePlanRes.status === 'fulfilled' ? safeParse(retirePlanRes.value) : null,+ retirement_planning: retirePlanningRes.status === 'fulfilled' ? safeParse(retirePlanningRes.value) : null,+ retirement_projection_fallback: { projected_value: projectedValue, assumed_return: assumedRet, annual_contribution: annualContrib },+ // Sub-tab: BEHAVIORAL+ behavioral_biases: biasesRes.status === 'fulfilled' ? safeParse(biasesRes.value) : null,+ behavioral_finance: behavFinRes.status === 'fulfilled' ? safeParse(behavFinRes.value) : null,+ // Sub-tab: ETF ANALYSIS+ etf_costs: etfCostsRes.status === 'fulfilled' ? safeParse(etfCostsRes.value) : null,+ etf_analysis: etfAnalysisRes.status === 'fulfilled' ? safeParse(etfAnalysisRes.value) : null,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 9. ECONOMICS — EconomicsPanel (CORRECTED command names)+ // Sub-tabs: BUSINESS CYCLE | EQUITY RISK PREMIUM | PORTFOLIO OVERVIEW | ACTIVE MANAGEMENT+ // invoke(): analyze_business_cycle, comprehensive_economics_analysis,+ // analyze_equity_risk_premium, get_portfolio_overview,+ // analyze_active_management, analyze_manager_selection+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_economics_overlay',+ description:+ 'Overlay macro context on the portfolio across all four sub-tabs of the ECONOMICS panel: '+ + '(1) BUSINESS CYCLE — analyze_business_cycle + comprehensive_economics_analysis; '+ + '(2) EQUITY RISK PREMIUM — analyze_equity_risk_premium with risk-free rate + market premium; '+ + '(3) PORTFOLIO OVERVIEW — get_portfolio_overview with returns/weights; '+ + '(4) ACTIVE MANAGEMENT — analyze_active_management + analyze_manager_selection. '+ + 'Also computes cyclical vs defensive sector exposure.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ cycle_phase: { type: 'string', description: 'Business cycle phase', enum: ['expansion','peak','contraction','trough','recovery'], default: 'expansion' },+ risk_free_rate: { type: 'number', description: 'Risk-free rate for ERP (default: 0.04)', default: 0.04 },+ market_risk_premium: { type: 'number', description: 'Market risk premium (default: 0.055)', default: 0.055 },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const cyclePhase = args.cycle_phase ?? 'expansion';+ const rfRate = args.risk_free_rate ?? 0.04;+ const mrp = args.market_risk_premium ?? 0.055;++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ const returnsJson = JSON.stringify(toReturns(holdings));+ const weightsJson = JSON.stringify(toWeights(holdings));++ const fundData = JSON.stringify({ returns: toReturns(holdings), weights: toWeights(holdings) });+ const managerCandidates = JSON.stringify([{ name: 'Current Portfolio', returns: toReturns(holdings) }]);++ // All 6 commands — exact names from EconomicsPanel.tsx+ const [cycleRes, ecoRes, erpRes, overviewRes, activeMgmtRes, managerSelRes] = await Promise.allSettled([+ si<string>('analyze_business_cycle', { cycle_phase: cyclePhase }),+ si<string>('comprehensive_economics_analysis', { cycle_phase: cyclePhase }),+ si<string>('analyze_equity_risk_premium', { risk_free_rate: rfRate, market_risk_premium: mrp }),+ si<string>('get_portfolio_overview', { returns_data: returnsJson, weights: weightsJson }),+ si<string>('analyze_active_management', { fund_data: fundData }),+ si<string>('analyze_manager_selection', { manager_candidates: managerCandidates }),+ ]);++ // Cyclical/defensive split+ const CYCLICAL = ['Technology','Consumer Cyclical','Financial Services','Industrials','Basic Materials','Energy','Communication Services'];+ const DEFENSIVE = ['Healthcare','Consumer Defensive','Utilities','Real Estate'];+ const sectorWeights: Record<string, number> = {};+ for (const h of holdings) {+ const s = (h.sector as string | undefined) ?? 'Unknown';+ sectorWeights[s] = (sectorWeights[s] ?? 0) + (h.weight ?? 0);+ }+ const cyclical = Object.entries(sectorWeights).filter(([s]) => CYCLICAL.some(c => s.includes(c))).reduce((n, [,w]) => n + w, 0);+ const defensive = Object.entries(sectorWeights).filter(([s]) => DEFENSIVE.some(d => s.includes(d))).reduce((n, [,w]) => n + w, 0);++ let message = `=== ECONOMICS OVERLAY ===\nPhase: ${cyclePhase.toUpperCase()} | RF: ${(rfRate*100).toFixed(1)}% | MRP: ${(mrp*100).toFixed(1)}%\n\n`;+ message += `SECTOR POSITIONING:\n Cyclical: ${cyclical.toFixed(1)}% | Defensive: ${defensive.toFixed(1)}% | Other: ${Math.max(0,100-cyclical-defensive).toFixed(1)}%\n\n`;++ const cycle = cycleRes.status === 'fulfilled' ? safeParse(cycleRes.value) : null;+ const erp = erpRes.status === 'fulfilled' ? safeParse(erpRes.value) : null;+ if (cycle) message += `BUSINESS CYCLE: ${JSON.stringify(cycle)}\n\n`;+ if (erp) message += `EQUITY RISK PREMIUM: ${JSON.stringify(erp)}\n\n`;++ return {+ success: true,+ data: {+ cycle_phase: cyclePhase, risk_free_rate: rfRate, market_risk_premium: mrp,+ portfolio_value: summary?.total_market_value,+ sector_weights: sectorWeights,+ macro_positioning: { cyclical_pct: cyclical, defensive_pct: defensive, other_pct: Math.max(0, 100 - cyclical - defensive) },+ // Sub-tab: BUSINESS CYCLE+ business_cycle: cycleRes.status === 'fulfilled' ? safeParse(cycleRes.value) : null,+ economics_analysis: ecoRes.status === 'fulfilled' ? safeParse(ecoRes.value) : null,+ // Sub-tab: EQUITY RISK PREMIUM+ equity_risk_premium: erpRes.status === 'fulfilled' ? safeParse(erpRes.value) : null,+ // Sub-tab: PORTFOLIO OVERVIEW+ portfolio_overview: overviewRes.status === 'fulfilled' ? safeParse(overviewRes.value) : null,+ // Sub-tab: ACTIVE MANAGEMENT+ active_management: activeMgmtRes.status === 'fulfilled' ? safeParse(activeMgmtRes.value) : null,+ manager_selection: managerSelRes.status === 'fulfilled' ? safeParse(managerSelRes.value) : null,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // 10. FFN VIEW — FFNView (top-level view, toggled by FFN button)+ // invoke(): execute_yfinance_command, ffn_full_analysis,+ // ffn_benchmark_comparison, ffn_portfolio_optimization,+ // ffn_rebase_prices, ffn_calculate_drawdowns,+ // ffn_calculate_rolling_metrics+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_ffn_analysis',+ description:+ 'Run FFN (Financial Functions) analysis on the portfolio. Returns all six sections: '+ + '(1) FULL ANALYSIS — ffn_full_analysis: per-asset metrics (CAGR, Sharpe, Sortino, MaxDD, Vol, Calmar); '+ + '(2) BENCHMARK COMPARISON — ffn_benchmark_comparison vs configurable benchmark; '+ + '(3) OPTIMIZATION — ffn_portfolio_optimization with ERC (equal risk contribution); '+ + '(4) REBASED PRICES — ffn_rebase_prices normalised to base 100; '+ + '(5) DRAWDOWNS — ffn_calculate_drawdowns: top periods with start/end/magnitude; '+ + '(6) ROLLING METRICS — ffn_calculate_rolling_metrics (30-day Sharpe/Vol/Sortino). '+ + 'This is the FFN view triggered by the FFN button in the Portfolio tab.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ benchmark: { type: 'string', description: 'Benchmark ticker', default: 'SPY' },+ rolling_window:{ type: 'number', description: 'Rolling metrics window (days)', default: 30 },+ lookback_days: { type: 'number', description: 'Historical price lookback (days)', default: 365 },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const benchmark = args.benchmark ?? 'SPY';+ const rollingWin = args.rolling_window ?? 30;+ const lookbackDays = args.lookback_days ?? 365;++ const summary = await contexts.getPortfolioSummary(args.portfolio_id);+ const holdings: any[] = summary?.holdings ?? [];+ if (holdings.length === 0) return { success: true, data: {}, message: 'Portfolio has no holdings.' };++ const symbols = holdings.map((h: any) => h.symbol);+ const endDate = new Date();+ const startDate= new Date(endDate.getTime() - lookbackDays * 24 * 60 * 60 * 1000);+ const fmt = (d: Date) => d.toISOString().split('T')[0];++ // Fetch historical prices for all holdings + benchmark — same as FFNView does+ const priceResults = await Promise.allSettled(+ [...symbols, benchmark].map(sym =>+ si<string>('execute_yfinance_command', { command: 'historical', args: [sym, fmt(startDate), fmt(endDate), '1d'] })+ )+ );++ // Build prices map: { AAPL: { '2024-01-02': 185.0, ... }, ... }+ const pricesMap: Record<string, Record<string, number>> = {};+ [...symbols, benchmark].forEach((sym, i) => {+ const r = priceResults[i];+ if (r.status === 'fulfilled' && r.value) {+ const data: any[] = safeParse(r.value) ?? [];+ pricesMap[sym] = {};+ for (const pt of data) {+ const date = pt.date ?? pt.timestamp ?? '';+ if (date) pricesMap[sym][date] = pt.close ?? pt.price ?? 0;+ }+ }+ });++ const pricesJson = JSON.stringify(pricesMap);+ const benchmarkPricesJson = JSON.stringify({ [benchmark]: pricesMap[benchmark] ?? {} });++ // Run all 6 FFN commands in parallel — exact names from FFNView.tsx+ const [fullRes, benchRes, optRes, rebaseRes, ddRes, rollingRes] = await Promise.allSettled([+ si<string>('ffn_full_analysis', { prices_json: pricesJson }),+ si<string>('ffn_benchmark_comparison', { prices_json: pricesJson, benchmark_prices_json: benchmarkPricesJson, benchmark_name: benchmark }),+ si<string>('ffn_portfolio_optimization', { prices_json: pricesJson, method: 'erc' }),+ si<string>('ffn_rebase_prices', { prices_json: pricesJson, base_value: 100.0 }),+ si<string>('ffn_calculate_drawdowns', { prices_json: pricesJson }),+ si<string>('ffn_calculate_rolling_metrics', { prices_json: pricesJson, window: rollingWin }),+ ]);++ const fullAnalysis = fullRes.status === 'fulfilled' ? safeParse(fullRes.value) : null;++ let message = `=== FFN ANALYSIS ===\nSymbols: ${symbols.join(', ')} Benchmark: ${benchmark}\n`;+ message += `Period: ${fmt(startDate)} → ${fmt(endDate)} (${lookbackDays}d)\n\n`;++ if (fullAnalysis) {+ message += `FULL ANALYSIS:\n`;+ for (const sym of symbols) {+ const m = fullAnalysis[sym] ?? fullAnalysis?.metrics?.[sym];+ if (m) {+ message += ` ${sym}: CAGR ${(m.cagr_pct ?? m.cagr * 100 ?? 0).toFixed(1)}%`;+ if (m.sharpe_ratio !== undefined) message += ` Sharpe ${m.sharpe_ratio.toFixed(2)}`;+ if (m.max_drawdown !== undefined) message += ` MaxDD ${(m.max_drawdown * 100).toFixed(1)}%`;+ message += '\n';+ }+ }+ }++ const opt = optRes.status === 'fulfilled' ? safeParse(optRes.value) : null;+ if (opt?.weights) {+ message += `\nERC OPTIMAL WEIGHTS:\n`;+ for (const [sym, w] of Object.entries(opt.weights))+ message += ` ${sym}: ${((w as number) * 100).toFixed(1)}%\n`;+ }++ return {+ success: true,+ data: {+ benchmark, rolling_window: rollingWin, lookback_days: lookbackDays,+ symbols, portfolio_value: summary?.total_market_value,+ prices_available: Object.fromEntries(Object.entries(pricesMap).map(([k, v]) => [k, Object.keys(v).length])),+ // Section: FULL ANALYSIS+ full_analysis: fullRes.status === 'fulfilled' ? safeParse(fullRes.value) : null,+ // Section: BENCHMARK+ benchmark_comparison: benchRes.status === 'fulfilled' ? safeParse(benchRes.value) : null,+ // Section: OPTIMIZATION (ERC)+ optimization_erc: optRes.status === 'fulfilled' ? safeParse(optRes.value) : null,+ // Section: REBASED PRICES+ rebased_prices: rebaseRes.status === 'fulfilled' ? safeParse(rebaseRes.value) : null,+ // Section: DRAWDOWNS+ drawdowns: ddRes.status === 'fulfilled' ? safeParse(ddRes.value) : null,+ // Section: ROLLING METRICS+ rolling_metrics: rollingRes.status === 'fulfilled' ? safeParse(rollingRes.value) : null,+ },+ message,+ };+ },+ },++ // ═══════════════════════════════════════════════════════════════════════════+ // BONUS: get_portfolio_full_context — single-call complete snapshot+ // ═══════════════════════════════════════════════════════════════════════════+ {+ name: 'get_portfolio_full_context',+ description:+ 'Single-call comprehensive snapshot: summary, advanced metrics, risk metrics, '+ + 'diversification, sector breakdown, top/worst performers. '+ + 'Use when an AI agent needs the full portfolio picture in one shot.',+ inputSchema: {+ type: 'object',+ properties: {+ portfolio_id: { type: 'string', description: 'Portfolio ID' },+ },+ required: ['portfolio_id'],+ },+ handler: async (args, contexts) => {+ if (!contexts.getPortfolioSummary) return { success: false, error: 'Portfolio context not available' };++ const [sumRes, metRes, riskRes, divRes] = await Promise.allSettled([+ contexts.getPortfolioSummary(args.portfolio_id),+ contexts.calculateAdvancedMetrics ? contexts.calculateAdvancedMetrics(args.portfolio_id) : Promise.resolve(null),+ contexts.calculateRiskMetrics ? contexts.calculateRiskMetrics(args.portfolio_id) : Promise.resolve(null),+ contexts.analyzeDiversification ? contexts.analyzeDiversification(args.portfolio_id) : Promise.resolve(null),+ ]);++ const summary = sumRes.status === 'fulfilled' ? sumRes.value : null;+ const metrics = metRes.status === 'fulfilled' ? metRes.value : null;+ const risk = riskRes.status === 'fulfilled' ? riskRes.value : null;+ const div = divRes.status === 'fulfilled' ? divRes.value : null;++ const holdings: any[] = summary?.holdings ?? [];+ const totalValue = summary?.total_market_value ?? 0;++ const sectorWeights: Record<string, number> = {};+ for (const h of holdings) {+ const s = (h.sector as string | undefined) ?? 'Unknown';+ sectorWeights[s] = (sectorWeights[s] ?? 0) + (h.weight ?? 0);+ }++ const sorted = [...holdings].sort((a: any, b: any) => (b.unrealized_pnl_percent ?? 0) - (a.unrealized_pnl_percent ?? 0));++ let message = `=== FULL PORTFOLIO CONTEXT ===\n\n`;+ message += `"${summary?.portfolio?.name ?? 'Unknown'}"\n`;+ message += `Value: $${totalValue.toFixed(2)} | Cost: $${(summary?.total_cost_basis ?? 0).toFixed(2)}\n`;+ message += `P&L: ${(summary?.total_unrealized_pnl ?? 0) >= 0 ? '+' : ''}$${(summary?.total_unrealized_pnl ?? 0).toFixed(2)} (${(summary?.total_unrealized_pnl_percent ?? 0).toFixed(2)}%)\n`;+ message += `Day: ${(summary?.total_day_change ?? 0) >= 0 ? '+' : ''}$${(summary?.total_day_change ?? 0).toFixed(2)} (${(summary?.total_day_change_percent ?? 0).toFixed(2)}%)\n`;+ message += `Positions: ${holdings.length}\n`;+ if (sorted.length > 0) {+ message += `Best: ${sorted[0].symbol} (${sorted[0].unrealized_pnl_percent?.toFixed(1)}%)\n`;+ message += `Worst: ${sorted[sorted.length-1].symbol} (${sorted[sorted.length-1].unrealized_pnl_percent?.toFixed(1)}%)\n`;+ }+ message += `Sectors: ${Object.entries(sectorWeights).map(([s,w]) => `${s} ${w.toFixed(0)}%`).join(' | ')}\n`;+ if (metrics) message += `Risk: Sharpe ${metrics.sharpe_ratio?.toFixed(2)}, Vol ${(metrics.portfolio_volatility*100)?.toFixed(1)}%, MaxDD ${(metrics.max_drawdown*100)?.toFixed(1)}%\n`;++ return {+ success: true,+ data: {+ summary: {+ portfolio: summary?.portfolio,+ total_market_value: totalValue,+ total_cost_basis: summary?.total_cost_basis,+ total_unrealized_pnl: summary?.total_unrealized_pnl,+ total_unrealized_pnl_percent: summary?.total_unrealized_pnl_percent,+ total_day_change: summary?.total_day_change,+ total_day_change_percent: summary?.total_day_change_percent,+ positions_count: holdings.length,+ },+ holdings: holdings.map((h: any) => ({+ symbol: h.symbol, quantity: h.quantity,+ current_price: h.current_price, market_value: h.market_value,+ unrealized_pnl: h.unrealized_pnl, unrealized_pnl_percent: h.unrealized_pnl_percent,+ day_change_percent: h.day_change_percent, weight: h.weight, sector: h.sector,+ })),+ sector_weights: sectorWeights,+ advanced_metrics: metrics,+ risk_metrics: risk,+ diversification: div,+ fetched_at: new Date().toISOString(),+ },+ message,+ };+ },+ },+];diff --git a/fincept-terminal-desktop/src/services/mcp/internal/types.ts b/fincept-terminal-desktop/src/services/mcp/internal/types.tsindex 002f563f6..eb5800789 100644--- a/fincept-terminal-desktop/src/services/mcp/internal/types.ts+++ b/fincept-terminal-desktop/src/services/mcp/internal/types.ts@@ -258,6 +258,36 @@ export interface TerminalContexts {getAvailableCategories?: () => string[];getAvailableRegions?: () => string[];+ // ============================================================================+ // Economics / Fincept Macro API+ // ============================================================================++ // CEIC Economic Series+ getFinceptCeicCountries?: () => Promise<Record<string, any>[]>;+ getFinceptCeicIndicators?: (countrySlug: string) => Promise<Record<string, any>[]>;+ getFinceptCeicSeries?: (params: {+ country: string;+ indicator?: string;+ yearFrom?: number;+ yearTo?: number;+ limit?: number;+ }) => Promise<Record<string, any>[]>;++ // Economic Calendar+ getFinceptEconomicCalendar?: (params: {+ startDate?: string;+ endDate?: string;+ limit?: number;+ }) => Promise<Record<string, any>[]>;+ getFinceptUpcomingEvents?: (limit?: number) => Promise<Record<string, any>[]>;++ // World Government Bonds+ getFinceptCentralBankRates?: () => Promise<Record<string, any>[]>;+ getFinceptCreditRatings?: () => Promise<Record<string, any>[]>;+ getFinceptSovereignCds?: () => Promise<Record<string, any>[]>;+ getFinceptBondSpreads?: () => Promise<Record<string, any>[]>;+ getFinceptInvertedYields?: () => Promise<Record<string, any>[]>;+// ============================================================================// Data Mapping// ============================================================================diff --git a/fincept-terminal-desktop/src/services/mcp/mcpBridge.ts b/fincept-terminal-desktop/src/services/mcp/mcpBridge.tsnew file mode 100644index 000000000..f29617a3d--- /dev/null+++ b/fincept-terminal-desktop/src/services/mcp/mcpBridge.ts@@ -0,0 +1,86 @@+/**+ * mcpBridge.ts - TypeScript side of the Python ↔ TypeScript MCP tool bridge+ *+ * Listens for "mcp-tool-call" Tauri events emitted by mcp_bridge.rs when a Python+ * finagent_core agent calls a terminal tool. Executes the tool via mcpToolService+ * and delivers the result back via the register_mcp_tool_result Tauri command.+ *+ * Initialized once at app startup via initMCPBridge().+ */++import { listen, UnlistenFn } from '@tauri-apps/api/event';+import { invoke } from '@tauri-apps/api/core';+import { mcpToolService } from './mcpToolService';+import { INTERNAL_SERVER_ID } from './internal';++interface MCPToolCallEvent {+ id: string;+ tool_name: string;+ args: Record<string, any>;+}++let _unlisten: UnlistenFn | null = null;+let _initialized = false;++/**+ * Initialize the MCP bridge listener.+ * Safe to call multiple times — only registers once.+ */+export async function initMCPBridge(): Promise<void> {+ if (_initialized) return;+ _initialized = true;++ try {+ _unlisten = await listen<MCPToolCallEvent>('mcp-tool-call', async (event) => {+ const { id, tool_name, args } = event.payload;++ if (!id || !tool_name) {+ console.warn('[MCPBridge] Received mcp-tool-call with missing id or tool_name', event.payload);+ return;+ }++ let result: string;+ try {+ const execResult = await mcpToolService.executeToolDirect(+ INTERNAL_SERVER_ID,+ tool_name,+ args || {}+ );+ result = JSON.stringify({+ success: execResult.success,+ data: execResult.data,+ error: execResult.error,+ message: execResult.message,+ });+ } catch (err: any) {+ result = JSON.stringify({+ success: false,+ error: err?.message || String(err),+ });+ }++ // Deliver result back to the waiting Rust HTTP bridge handler+ try {+ await invoke('register_mcp_tool_result', { id, result });+ } catch (err: any) {+ console.error('[MCPBridge] Failed to deliver tool result:', err);+ }+ });++ console.log('[MCPBridge] Initialized — listening for mcp-tool-call events');+ } catch (err) {+ console.error('[MCPBridge] Failed to initialize:', err);+ _initialized = false;+ }+}++/**+ * Tear down the bridge listener (e.g. on app unmount).+ */+export function destroyMCPBridge(): void {+ if (_unlisten) {+ _unlisten();+ _unlisten = null;+ }+ _initialized = false;+}diff --git a/fincept-terminal-desktop/src/services/nodeSystem/adapters/AgentBridge.ts b/fincept-terminal-desktop/src/services/nodeSystem/adapters/AgentBridge.tsindex 093334ce3..4f9c742d2 100644--- a/fincept-terminal-desktop/src/services/nodeSystem/adapters/AgentBridge.ts+++ b/fincept-terminal-desktop/src/services/nodeSystem/adapters/AgentBridge.ts@@ -362,7 +362,7 @@ const AGENT_DEFINITIONS: AgentMetadata[] = [// ==================== ECONOMIC AGENTS ===================={- id: 'capitalism_analyst',+ id: 'capitalism_agent',name: 'Capitalism Analyst',category: 'economic',description: 'Analyzes from free market capitalism perspective',@@ -373,7 +373,7 @@ const AGENT_DEFINITIONS: AgentMetadata[] = [],},{- id: 'keynesian_analyst',+ id: 'keynesian_agent',name: 'Keynesian Analyst',category: 'economic',description: 'Analyzes from Keynesian economics perspective',@@ -384,7 +384,7 @@ const AGENT_DEFINITIONS: AgentMetadata[] = [],},{- id: 'neoliberal_analyst',+ id: 'neoliberal_agent',name: 'Neoliberal Analyst',category: 'economic',description: 'Analyzes from neoliberal economics perspective',@@ -395,7 +395,7 @@ const AGENT_DEFINITIONS: AgentMetadata[] = [],},{- id: 'mixed_economy_analyst',+ id: 'mixed_economy_agent',name: 'Mixed Economy Analyst',category: 'economic',description: 'Analyzes from mixed economy perspective',@@ -486,7 +486,9 @@ class AgentBridgeClass {const result = await this.pythonAgentService.executeAgent(request.agentId,request.parameters,- request.inputs || {}+ request.inputs || {},+ request.llmProvider,+ request.llmModel,);return {