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
Trading tab update
tilakpatel22efdcbd92c7c0
diff --git a/.github/workflows/build-artifacts.yml b/.github/workflows/build-artifacts.ymlindex 0a1a58bf5..9e8db2548 100644--- a/.github/workflows/build-artifacts.yml+++ b/.github/workflows/build-artifacts.yml@@ -19,7 +19,7 @@ jobs:os_name: 'macOS'arch: 'x64'target: 'x86_64-apple-darwin'- - platform: 'ubuntu-20.04'+ - platform: 'ubuntu-latest'args: '--target x86_64-unknown-linux-gnu'os_name: 'Linux'arch: 'x64'@@ -37,7 +37,7 @@ jobs:uses: actions/checkout@v4- name: Install dependencies (ubuntu only)- if: matrix.platform == 'ubuntu-20.04'+ if: matrix.platform == 'ubuntu-latest'run: |sudo apt-get updatesudo apt-get install -y \@@ -140,7 +140,7 @@ jobs:find fincept-terminal-desktop/src-tauri/target/${{ matrix.target }}/release/bundle -name "*.dmg" -exec cp {} release-artifacts/FinceptTerminal-v${VERSION}-${SUFFIX}.dmg \; 2>/dev/null && echo "[OK] Found .dmg" || echo "[WARN] No .dmg found"- elif [[ "${{ matrix.platform }}" == "ubuntu-20.04" ]]; then+ elif [[ "${{ matrix.platform }}" == "ubuntu-latest" ]]; then# Linux buildsSUFFIX="Linux-x64"find fincept-terminal-desktop/src-tauri/target/${{ matrix.target }}/release/bundle -name "*.AppImage" -exec cp {} release-artifacts/FinceptTerminal-v${VERSION}-${SUFFIX}.AppImage \; 2>/dev/null && echo "[OK] Found .AppImage" || echo "[WARN] No .AppImage found"diff --git a/fincept-terminal-desktop/src-tauri/resources/requirements.txt b/fincept-terminal-desktop/src-tauri/resources/requirements.txtindex c96894574..e00a68fc0 100644--- a/fincept-terminal-desktop/src-tauri/resources/requirements.txt+++ b/fincept-terminal-desktop/src-tauri/resources/requirements.txt@@ -46,3 +46,7 @@ zstandard==0.25.0jinja2==3.1.3weasyprint==62.3matplotlib==3.9.3+# LLM Provider Packages (for finagent_core)+openai==2.8.1+anthropic==0.71.0+google-generativeai==0.8.5diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/black_hole_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/black_hole_agent.pydeleted file mode 100644index acf6aa9ff..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/black_hole_agent.py+++ /dev/null@@ -1,841 +0,0 @@-"""-BLACK HOLE AGENT-Post-Soviet Russia Analysis for Grand Chessboard Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - russian_events (array)-# - post_soviet_developments (array)-# - russian_capabilities (object)-# - russian_near_abroad_dynamics (object)-# - BLACK_HOLE_API_KEY-#-# OUTPUT:-# - Russian resurgence potential assessment-# - Near abroad influence analysis-# - Russian threat evaluation-# - Containment strategy recommendations-#-# PARAMETERS:-# - analysis_focus="russian_resurgence"-# - strategic_timeframe="decade"-# - perspective="western_containment"-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.containment_strategy import ContainmentStrategy-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class RussianTrajectory(Enum):- """Russia's strategic trajectory assessment"""- COLLAPSED = "collapsed" # Continued decline and internal fragmentation- CONTAINED = "contained" # Limited regional influence, contained by West- RESURGENT = "resurgent" # Regional power recovery and expansion- REVISIONIST = "revisionist" # Aggressive revision of post-Cold War order- FRAGMENTED = "fragmented" # Internal divisions reduce external power--class ContainmentStrategy(Enum):- """Western containment strategies for Russia"""- ENGAGEMENT = "engagement" # Diplomatic and economic engagement- ISOLATION = "isolation" # Political and economic isolation- BALANCING = "balancing" # Military and alliance balancing- COMPETITION = "competition" # Strategic competition in specific domains- DETERRENCE = "deterrence" # Military deterrence posture--@dataclass-class RussianCapabilities:- """Comprehensive assessment of Russian capabilities"""- military_capability: float # 0-1 scale- economic_strength: float # 0-1 scale- technological_level: float # 0-1 scale- diplomatic_influence: float # 0-1 scale- energy_leverage: float # 0-1 scale- information_warfare: float # 0-1 scale- internal_stability: float # 0-1 scale--@dataclass-class NearAbroadAssessment:- """Assessment of Russia's near abroad influence"""- regional_hegemony: Dict[str, float] # Influence by region- military_presence: Dict[str, bool] # Military footprint- economic_dependencies: Dict[str, List[str]] # Countries dependent on Russia- political_leverage: Dict[str, float] # Political influence level- resistance_potential: Dict[str, float] # Local resistance to Russian influence--class BlackHoleAgent:- """- BLACK HOLE AGENT - Post-Soviet Russia Analysis-- Core Thesis: Russia as diminished but potentially resurgent regional power- - Post-imperial collapse and demographic challenges affecting power- - Resource-based economy with industrial and technological weaknesses- - Great power ambitions focused on regional, not global dominance- - Strategic challenge requiring containment not confrontation- - Near abroad as critical sphere of influence-- Brzezinski Framework: Managing Russian resurgence while preventing expansion- """-- def __init__(self):- """Initialize the black hole agent"""- self.agent_id = "black_hole_agent"- self.containment_strategist = ContainmentStrategy()- self.balance_calculator = BalanceOfPowerCalculator()-- # Russia's near abroad regions- self.near_abroad_regions = [- "eastern_europe", "baltics", "caucasus", "central_asia",- "black_sea", "arctic", "western_europe"- ]-- # Key post-Soviet states- self.post_soviet_states = [- "ukraine", "belarus", "moldova", "georgia", "armenia", "azerbaijan",- "kazakhstan", "kyrgyzstan", "tajikistan", "turkmenistan", "uzbekistan",- "estonia", "latvia", "lithuania"- ]-- # Russian strategic imperatives- self.russian_imperatives = [- "prevent_nato_expansion", "reestablish_near_abroad_dominance",- "secure_warm_water_ports", "control_energy_transit_routes",- "maintain_great_power_status", "counter_american_encirclement"- ]-- def analyze_black_hole(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for Russian strategic assessment-- Args:- state: AgentState containing Russian geopolitical data-- Returns:- Comprehensive assessment of Russian black hole dynamics- """- try:- logger.info("Starting Black Hole analysis")-- # Extract relevant data from state- russian_events = state.get("russian_events", [])- post_soviet_developments = state.get("post_soviet_developments", [])- russian_capabilities = state.get("russian_capabilities", {})- near_abroad_dynamics = state.get("russian_near_abroad_dynamics", {})-- # Core Brzezinski analysis components- capabilities_assessment = self._assess_russian_capabilities(- russian_capabilities, post_soviet_developments- )-- trajectory_analysis = self._analyze_russian_trajectory(- capabilities_assessment, russian_events, post_soviet_developments- )-- near_abroad_assessment = self._evaluate_near_abroad_influence(- near_abroad_dynamics, russian_events, capabilities_assessment- )-- imperial_ambitions = self._assess_imperial_ambitions(- capabilities_assessment, trajectory_analysis, russian_events- )-- containment_needs = self._assess_containment_requirements(- capabilities_assessment, trajectory_analysis, near_abroad_assessment- )-- # Strategic opportunities and vulnerabilities- russian_vulnerabilities = self._identify_russian_vulnerabilities(- capabilities_assessment, near_abroad_dynamics- )-- western_opportunities = self._identify_western_opportunities(- capabilities_assessment, russian_vulnerabilities, near_abroad_assessment- )-- # Strategic recommendations- strategic_recommendations = self._generate_black_hole_recommendations(- trajectory_analysis, containment_needs, western_opportunities- )-- # Compile comprehensive assessment- black_hole_assessment = {- "assessment_type": "black_hole",- "timestamp": state.get("timestamp", ""),- "capabilities_assessment": capabilities_assessment,- "trajectory_analysis": trajectory_analysis,- "near_abroad_assessment": near_abroad_assessment,- "imperial_ambitions": imperial_ambitions,- "containment_needs": containment_needs,- "russian_vulnerabilities": russian_vulnerabilities,- "western_opportunities": western_opportunities,- "strategic_recommendations": strategic_recommendations,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- black_hole_assessment,- "Black Hole strategic analysis completed"- )-- logger.info("Black Hole analysis completed successfully")- return black_hole_assessment-- except Exception as e:- logger.error(f"Error in Black Hole analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _assess_russian_capabilities(- self,- capabilities_data: Dict[str, Any],- developments: List[Dict[str, Any]]- ) -> RussianCapabilities:- """Comprehensive assessment of current Russian capabilities"""-- # Military capability assessment- military_capability = self._assess_military_capability(capabilities_data)-- # Economic strength assessment- economic_strength = self._assess_economic_strength(capabilities_data)-- # Technological level assessment- technological_level = self._assess_technological_capability(capabilities_data)-- # Diplomatic influence assessment- diplomatic_influence = self._assess_diplomatic_influence(capabilities_data, developments)-- # Energy leverage assessment- energy_leverage = self._assess_energy_leverage(capabilities_data)-- # Information warfare capability- information_warfare = self._assess_information_warfare_capability(capabilities_data)-- # Internal stability assessment- internal_stability = self._assess_internal_stability(capabilities_data, developments)-- return RussianCapabilities(- military_capability=military_capability,- economic_strength=economic_strength,- technological_level=technological_level,- diplomatic_influence=diplomatic_influence,- energy_leverage=energy_leverage,- information_warfare=information_warfare,- internal_stability=internal_stability- )-- def _analyze_russian_trajectory(- self,- capabilities: RussianCapabilities,- events: List[Dict[str, Any]],- developments: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Analyze Russia's current strategic trajectory"""-- # Assess trajectory indicators- military_trend = self._assess_military_trajectory(events, capabilities.military_capability)- economic_trend = self._assess_economic_trajectory(events, capabilities.economic_strength)- political_trend = self._assess_political_trajectory(events, capabilities.internal_stability)- foreign_policy_trend = self._assess_foreign_policy_trajectory(events)-- # Determine overall trajectory- trajectory_score = (- military_trend * 0.25 +- economic_trend * 0.25 +- political_trend * 0.25 +- foreign_policy_trend * 0.25- )-- current_trajectory = self._determine_trajectory_type(trajectory_score, events)-- # Future trajectory projection- future_trajectory = self._project_future_trajectory(- capabilities, current_trajectory, developments- )-- # Critical turning points- turning_points = self._identify_turning_points(events, developments)-- # Trajectory drivers- trajectory_drivers = self._identify_trajectory_drivers(- capabilities, events, developments- )-- return {- "current_trajectory": current_trajectory,- "trajectory_score": trajectory_score,- "future_trajectory": future_trajectory,- "turning_points": turning_points,- "trajectory_drivers": trajectory_drivers,- "key_indicators": self._identify_trajectory_indicators(events),- "trajectory_confidence": self._assess_trajectory_confidence(events, capabilities),- "critical_factors": self._identify_trajectory_critical_factors(capabilities)- }-- def _evaluate_near_abroad_influence(- self,- near_abroad_data: Dict[str, Any],- events: List[Dict[str, Any]],- capabilities: RussianCapabilities- ) -> NearAbroadAssessment:- """Evaluate Russian influence in near abroad regions"""-- regional_hegemony = {}- military_presence = {}- economic_dependencies = {}- political_leverage = {}- resistance_potential = {}-- for region in self.near_abroad_regions:- # Regional hegemony assessment- regional_influence = near_abroad_data.get(region, {}).get("russian_influence", 0.5)- regional_hegemony[region] = regional_influence-- # Military presence- military_presence[region] = near_abroad_data.get(region, {}).get("military_presence", False)-- # Economic dependencies- dependent_states = near_abroad_data.get(region, {}).get("dependent_states", [])- economic_dependencies[region] = dependent_states-- # Political leverage- political_leverage[region] = near_abroad_data.get(region, {}).get("political_leverage", 0.5)-- # Resistance potential- resistance_potential[region] = near_abroad_data.get(region, {}).get("resistance_level", 0.5)-- # Overall near abroad assessment- total_influence = sum(regional_hegemony.values()) / len(regional_hegemony)- expansion_potential = self._assess_expansion_potential(- regional_hegemony, resistance_potential, capabilities- )-- return NearAbroadAssessment(- regional_hegemony=regional_hegemony,- military_presence=military_presence,- economic_dependencies=economic_dependencies,- political_leverage=political_leverage,- resistance_potential=resistance_potential- )-- def _assess_imperial_ambitions(- self,- capabilities: RussianCapabilities,- trajectory: Dict[str, Any],- events: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Assess Russia's imperial ambitions and restoration goals"""-- # Imperial ambition indicators- territorial_ambitions = self._assess_territorial_ambitions(events)- sphere_of_influence_goals = self._assess_sphere_influence_goals(events)- great_power_aspirations = self._assess_great_power_aspirations(events)-- # Capability-ambition alignment- ambition_capability_gap = self._assess_ambition_capability_gap(- capabilities, territorial_ambitions, sphere_of_influence_goals- )-- # Historical parallels- historical_patterns = self._identify_historical_imperial_patterns(events)-- # Soviet nostalgia assessment- soviet_nostalgia = self._assess_soviet_nostalgia(events)-- # Imperial strategy assessment- imperial_strategy = self._assess_imperial_strategy(events, trajectory)-- return {- "overall_ambition_level": self._calculate_ambition_level(- territorial_ambitions, sphere_of_influence_goals, great_power_aspirations- ),- "territorial_ambitions": territorial_ambitions,- "sphere_of_influence_goals": sphere_of_influence_goals,- "great_power_aspirations": great_power_aspirations,- "ambition_capability_gap": ambition_capability_gap,- "historical_patterns": historical_patterns,- "soviet_nostalgia": soviet_nostalgia,- "imperial_strategy": imperial_strategy,- "revisionist_potential": self._assess_revisionist_potential(events, trajectory),- "risk_assessment": self._assess_imperial_risk(ambition_capability_gap, capabilities)- }-- def _assess_containment_requirements(- self,- capabilities: RussianCapabilities,- trajectory: Dict[str, Any],- near_abroad: NearAbroadAssessment- ) -> Dict[str, Any]:- """Assess Western containment requirements for Russia"""-- # Containment necessity assessment- containment_necessity = self._assess_containment_necessity(- capabilities, trajectory, near_abroad- )-- # Optimal containment strategy- optimal_strategy = self._determine_optimal_containment_strategy(- capabilities, trajectory, near_abroad- )-- # Regional containment needs- regional_needs = {}- for region in self.near_abroad_regions:- region_needs = self._assess_regional_containment_needs(- region, capabilities, near_abroad.regional_hegemony.get(region, 0.5)- )- regional_needs[region] = region_needs-- # Capability-specific containment- military_containment = self._assess_military_containment_needs(capabilities)- economic_containment = self._assess_economic_containment_needs(capabilities)- diplomatic_containment = self._assess_diplomatic_containment_needs(near_abroad)-- # Alliance requirements- alliance_requirements = self._assess_containment_alliance_requirements(- capabilities, trajectory, regional_needs- )-- return {- "containment_necessity": containment_necessity,- "optimal_strategy": optimal_strategy,- "regional_needs": regional_needs,- "military_containment": military_containment,- "economic_containment": economic_containment,- "diplomatic_containment": diplomatic_containment,- "alliance_requirements": alliance_requirements,- "containment_priorities": self._prioritize_containment_efforts(regional_needs),- "implementation_challenges": self._identify_containment_challenges(capabilities)- }-- def _identify_russian_vulnerabilities(- self,- capabilities: RussianCapabilities,- near_abroad_data: Dict[str, Any]- ) -> List[str]:- """Identify key Russian strategic vulnerabilities"""-- vulnerabilities = []-- # Capability-based vulnerabilities- if capabilities.economic_strength < 0.5:- vulnerabilities.append("Economic overdependence on energy exports")- vulnerabilities.append("Limited industrial diversification")-- if capabilities.technological_level < 0.6:- vulnerabilities.append("Technological lag in critical sectors")- vulnerabilities.append("Dependence on foreign technology")-- if capabilities.internal_stability < 0.6:- vulnerabilities.append("Domestic political and social tensions")- vulnerabilities.append("Demographic challenges affecting long-term power")-- # Near abroad vulnerabilities- high_resistance_regions = [- region for region, resistance in near_abroad_data.items()- if resistance.get("resistance_level", 0.5) > 0.7- ]-- if high_resistance_regions:- vulnerabilities.append(- f"Strong local resistance in {', '.join(high_resistance_regions)}"- )-- # Structural vulnerabilities- vulnerabilities.extend([- "Geographic vulnerabilities (access to warm water ports)",- "Demographic decline affecting long-term power",- "Overextension risks in near abroad ambitions",- "Sanctions vulnerability due to economic structure",- "Information warfare backlash and credibility issues"- ])-- return vulnerabilities-- def _identify_western_opportunities(- self,- capabilities: RussianCapabilities,- vulnerabilities: List[str],- near_abroad: NearAbroadAssessment- ) -> List[str]:- """Identify strategic opportunities for Western engagement"""-- opportunities = []-- # Opportunities based on Russian vulnerabilities- if "Economic overdependence" in str(vulnerabilities):- opportunities.append(- "Exploit Russian economic vulnerabilities through targeted sanctions"- )- opportunities.append(- "Offer alternative energy partnerships to reduce Russian leverage"- )-- if "Technological lag" in str(vulnerabilities):- opportunities.append(- "Maintain technological superiority in critical domains"- )- opportunities.append(- "Limit Russian access to advanced military and dual-use technologies"- )-- # Near abroad opportunities- low_influence_regions = [- region for region, influence in near_abroad.regional_hegemony.items()- if influence < 0.4- ]-- if low_influence_regions:- opportunities.append(- f"Strengthen Western influence in {', '.join(low_influence_regions)}"- )- opportunities.append(- "Support regional resistance to Russian expansion"- )-- # Strategic opportunities- if capabilities.internal_stability < 0.6:- opportunities.append(- "Support democratic forces and civil society in Russia"- )-- opportunities.extend([- "Leverage energy market transitions to reduce Russian leverage",- "Strengthen NATO's eastern flank to deter Russian aggression",- "Develop alternatives to Russian influence in post-Soviet space",- "Exploit Russian isolation through diplomatic engagement"- ])-- return opportunities-- def _generate_black_hole_recommendations(- self,- trajectory: Dict[str, Any],- containment_needs: Dict[str, Any],- opportunities: List[str]- ) -> List[str]:- """Generate strategic recommendations for managing Russian challenge"""-- recommendations = []-- # Trajectory-specific recommendations- if trajectory.get("current_trajectory") == RussianTrajectory.RESURGENT:- recommendations.append(- "Implement comprehensive containment strategy to prevent Russian resurgence"- )- recommendations.append(- "Strengthen NATO eastern flank and military capabilities"- )- elif trajectory.get("current_trajectory") == RussianTrajectory.REVISIONIST:- recommendations.append(- "Prepare for decisive response to Russian revisionist actions"- )- recommendations.append(- "Maintain credible deterrence posture against Russian aggression"- )-- # Containment strategy recommendations- optimal_strategy = containment_needs.get("optimal_strategy", ContainmentStrategy.BALANCING)- if optimal_strategy == ContainmentStrategy.BALANCING:- recommendations.append(- "Implement balanced approach of deterrence and limited engagement"- )- elif optimal_strategy == ContainmentStrategy.DETERRENCE:- recommendations.append(- "Focus on military deterrence and alliance strengthening"- )-- # Regional recommendations- high_priority_regions = containment_needs.get("containment_priorities", [])- for region in high_priority_regions[:3]: # Top 3 priority regions- recommendations.append(- f"Prioritize containment efforts in {region.replace('_', ' ').title()}"- )-- # Exploit opportunities- if opportunities:- recommendations.extend(opportunities[:5]) # Top 5 opportunities-- # Core containment principles- recommendations.extend([- "Maintain unity among Western allies on Russia policy",- "Coordinate economic sanctions and diplomatic pressure",- "Support sovereignty and independence of post-Soviet states",- "Preserve NATO credibility and Article 5 commitments",- "Develop long-term strategy for managing Russian challenge"- ])-- return recommendations-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's Russia framework"""-- validation_criteria = {- "black_hole_recognition": True, # Russia as post-imperial diminished power- "near_abroad_focus": True, # Emphasis on sphere of influence- "containment_prevention": True, # Containment not confrontation- "great_power_ambitions": True, # Recognition of great power aspirations- "regional_not_global": True, # Regional rather than global ambitions- "american_responsibility": True # American leadership in managing Russia- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "Russia as post-imperial 'black hole' with diminished power",- "Near abroad as critical sphere of Russian influence",- "Containment through alliance network rather than direct confrontation",- "Recognition of Russian great power ambitions despite limitations",- "Prevention of Russian regional hegemony as strategic imperative",- "American leadership in managing Russian challenge"- ]- }-- def _calculate_confidence_score(self, state: AgentState) -> float:- """Calculate confidence score for black hole assessment"""-- # Data quality assessment- data_completeness = self._assess_data_completeness(state)- data_recency = self._assess_data_recency(state)-- # Analytical clarity- event_relevance = self._assess_event_relevance(state)- capability_coverage = self._assess_capability_coverage(state)-- # Calculate weighted confidence- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- event_relevance * 0.35 +- capability_coverage * 0.25- )-- return min(confidence, 1.0)-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""-- return {- "assessment_type": "black_hole",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Maintain vigilant containment of Russian expansion",- "Support sovereignty of post-Soviet states",- "Strengthen NATO's eastern flank capabilities",- "Monitor Russian military and political developments"- ],- "confidence_score": 0.0- }-- # Helper method implementations- def _assess_military_capability(self, capabilities_data: Dict[str, Any]) -> float:- """Assess Russian military capability on 0-1 scale"""- # Simplified implementation - would be more sophisticated in production- nuclear_capability = capabilities_data.get("nuclear_capability", 0.9)- conventional_forces = capabilities_data.get("conventional_forces", 0.6)- modernization_level = capabilities_data.get("military_modernization", 0.5)- power_projection = capabilities_data.get("power_projection", 0.4)-- return (nuclear_capability * 0.3 + conventional_forces * 0.3 +- modernization_level * 0.2 + power_projection * 0.2)-- def _assess_economic_strength(self, capabilities_data: Dict[str, Any]) -> float:- """Assess Russian economic strength on 0-1 scale"""- gdp_size = capabilities_data.get("gdp_relative", 0.4)- energy_dependence = capabilities_data.get("energy_dependence", 0.8)- industrial_base = capabilities_data.get("industrial_base", 0.5)- economic_resilience = capabilities_data.get("economic_resilience", 0.4)-- return (gdp_size * 0.3 + (1 - energy_dependence) * 0.25 +- industrial_base * 0.25 + economic_resilience * 0.2)-- def _assess_technological_capability(self, capabilities_data: Dict[str, Any]) -> float:- """Assess Russian technological capability on 0-1 scale"""- military_tech = capabilities_data.get("military_technology", 0.6)- civilian_tech = capabilities_data.get("civilian_technology", 0.4)- innovation_capacity = capabilities_data.get("innovation_capacity", 0.3)- tech_independence = capabilities_data.get("technological_independence", 0.5)-- return (military_tech * 0.4 + civilian_tech * 0.3 +- innovation_capacity * 0.2 + tech_independence * 0.1)-- def _assess_diplomatic_influence(self, capabilities_data: Dict[str, Any], developments: List[Dict]) -> float:- """Assess Russian diplomatic influence on 0-1 scale"""- un_influence = capabilities_data.get("un_influence", 0.6)- regional_leadership = capabilities_data.get("regional_leadership", 0.7)- alliance_network = capabilities_data.get("alliance_network", 0.5)- soft_power = capabilities_data.get("soft_power", 0.4)-- return (un_influence * 0.3 + regional_leadership * 0.3 +- alliance_network * 0.25 + soft_power * 0.15)-- def _assess_energy_leverage(self, capabilities_data: Dict[str, Any]) -> float:- """Assess Russian energy leverage on 0-1 scale"""- energy_reserves = capabilities_data.get("energy_reserves", 0.9)- export_markets = capabilities_data.get("energy_markets", 0.8)- transit_control = capabilities_data.get("transit_control", 0.6)- energy_weaponization = capabilities_data.get("energy_weaponization", 0.7)-- return (energy_reserves * 0.3 + export_markets * 0.3 +- transit_control * 0.2 + energy_weaponization * 0.2)-- def _assess_information_warfare_capability(self, capabilities_data: Dict[str, Any]) -> float:- """Assess Russian information warfare capability on 0-1 scale"""- disinformation_capacity = capabilities_data.get("disinformation_capacity", 0.8)- cyber_capability = capabilities_data.get("cyber_capability", 0.7)- media_influence = capabilities_data.get("media_influence", 0.6)- psychological_operations = capabilities_data.get("psyops_capability", 0.7)-- return (disinformation_capacity * 0.3 + cyber_capability * 0.3 +- media_influence * 0.2 + psychological_operations * 0.2)-- def _assess_internal_stability(self, capabilities_data: Dict[str, Any], developments: List[Dict]) -> float:- """Assess Russian internal stability on 0-1 scale"""- political_stability = capabilities_data.get("political_stability", 0.6)- social_cohesion = capabilities_data.get("social_cohesion", 0.5)- economic_satisfaction = capabilities_data.get("economic_satisfaction", 0.5)- demographic_health = capabilities_data.get("demographic_health", 0.4)-- return (political_stability * 0.3 + social_cohesion * 0.3 +- economic_satisfaction * 0.2 + demographic_health * 0.2)-- # Additional helper methods for complete functionality- def _determine_trajectory_type(self, score: float, events: List[Dict]) -> RussianTrajectory:- """Determine Russian trajectory type"""- if score > 0.7:- return RussianTrajectory.RESURGENT- elif score > 0.5:- return RussianTrajectory.CONTAINED- elif score > 0.3:- return RussianTrajectory.FRAGMENTED- else:- return RussianTrajectory.COLLAPSED-- def _assess_data_completeness(self, state: AgentState) -> float:- """Assess completeness of input data"""- required_fields = ["russian_events", "russian_capabilities", "russian_near_abroad_dynamics"]- present_fields = sum(1 for field in required_fields if state.get(field))- return present_fields / len(required_fields)-- def _assess_data_recency(self, state: AgentState) -> float:- """Assess recency of input data"""- return 0.8 # Assume reasonably current data-- def _assess_event_relevance(self, state: AgentState) -> float:- """Assess relevance of events to black hole analysis"""- events = state.get("russian_events", [])- relevant_events = sum(1 for event in events- if event.get("military_action") or event.get("political_crisis"))- return relevant_events / len(events) if events else 0-- def _assess_capability_coverage(self, state: AgentState) -> float:- """Assess coverage of Russian capability data"""- capabilities = state.get("russian_capabilities", {})- key_capabilities = ["military", "economic", "technology", "energy"]- covered_capabilities = sum(1 for cap in key_capabilities if capabilities.get(cap))- return covered_capabilities / len(key_capabilities)--# Main agent function following existing patterns-def black_hole_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function for Russian black hole analysis-- Args:- state: AgentState with Russian geopolitical data-- Returns:- Strategic assessment of Russian black hole dynamics- """- agent = BlackHoleAgent()- return agent.analyze_black_hole(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "russian_events": [- {"id": "1", "type": "military", "description": "Russian military exercises near Baltic borders", "military_action": True},- {"id": "2", "type": "political", "description": "Russia opposes NATO expansion", "political_crises": True},- {"id": "3", "type": "economic", "description": "Russia develops new energy export routes", "energy_weaponization": True}- ],- "post_soviet_developments": [- {"id": "1", "type": "political", "description": "Belarus deepens integration with Russia"},- {"id": "2", "type": "military", "description": "Russian military presence in Central Asia increases"}- ],- "russian_capabilities": {- "nuclear_capability": 0.9,- "conventional_forces": 0.6,- "military_modernization": 0.5,- "power_projection": 0.4,- "gdp_relative": 0.4,- "energy_dependence": 0.8,- "industrial_base": 0.5,- "economic_resilience": 0.4,- "military_technology": 0.6,- "civilian_technology": 0.4,- "innovation_capacity": 0.3,- "technological_independence": 0.5,- "un_influence": 0.6,- "regional_leadership": 0.7,- "alliance_network": 0.5,- "soft_power": 0.4,- "energy_reserves": 0.9,- "energy_markets": 0.8,- "transit_control": 0.6,- "energy_weaponization": 0.7,- "disinformation_capacity": 0.8,- "cyber_capability": 0.7,- "media_influence": 0.6,- "psyops_capability": 0.7,- "political_stability": 0.6,- "social_cohesion": 0.5,- "economic_satisfaction": 0.5,- "demographic_health": 0.4- },- "russian_near_abroad_dynamics": {- "eastern_europe": {- "russian_influence": 0.6,- "military_presence": False,- "political_leverage": 0.5,- "resistance_level": 0.7- },- "caucasus": {- "russian_influence": 0.7,- "military_presence": True,- "political_leverage": 0.6,- "resistance_level": 0.5- },- "central_asia": {- "russian_influence": 0.5,- "military_presence": False,- "political_leverage": 0.4,- "resistance_level": 0.4- }- }- }-- result = black_hole_agent(test_state)- print("Black Hole Analysis Results:")- print(f"Current Trajectory: {result.get('trajectory_analysis', {}).get('current_trajectory', 'unknown')}")- print(f"Military Capability: {result.get('capabilities_assessment', {}).get('military_capability', 0):.2f}")- print(f"Economic Strength: {result.get('capabilities_assessment', {}).get('economic_strength', 0):.2f}")- print(f"Containment Necessity: {result.get('containment_needs', {}).get('containment_necessity', 'unknown')}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/democratic_bridgehead_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/democratic_bridgehead_agent.pydeleted file mode 100644index 095c4c1e1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/democratic_bridgehead_agent.py+++ /dev/null@@ -1,766 +0,0 @@-"""-DEMOCRATIC BRIDGEHEAD AGENT-European Strategic Analysis for Grand Chessboard Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - european_events (array)-# - nato_developments (array)-# - eu_integration_data (object)-# - european_economic_indicators (object)-# - DEMOCRATIC_BRIDGEHEAD_API_KEY-#-# OUTPUT:-# - European integration assessment-# - NATO strategic effectiveness analysis-# - Transatlantic relationship evaluation-# - Western stability recommendations-#-# PARAMETERS:-# - analysis_focus="european_integration"-# - strategic_timeframe="decade"-# - perspective="transatlantic"-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.alliance_management import AllianceManager-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class IntegrationStatus(Enum):- """European Union integration status"""- DEEPENING = "deepening" # Moving toward deeper integration- STAGNATING = "stagnating" # Integration progress stalled- FRAGMENTING = "fragmenting" # Risk of disintegration- EXPANDING = "expanding" # New members joining- REFORMING = "reforming" # Major institutional reforms--class NATOStrategicValue(Enum):- """NATO's strategic value assessment"""- ESSENTIAL = "essential" # Critical to European security- STRONG = "strong" # Important but with challenges- EVOLVING = "evolving" # Adapting to new challenges- QUESTIONED = "questioned" # Future role debated- TRANSFORMING = "transforming" # Major transformation underway--@dataclass-class EuropeanAssessment:- """Comprehensive European strategic assessment"""- integration_status: IntegrationStatus- nato_effectiveness: NATOStrategicValue- transatlantic_strength: float # 0-1 scale- strategic_challenges: List[str]- american_opportunities: List[str]- regional_stability: str # stable, tense, unstable- strategic_recommendations: List[str]--@dataclass-class BridgeheadMetrics:- """Metrics for democratic bridgehead effectiveness"""- political_cohesion: float # 0-1 scale- economic_integration: float # 0-1 scale- defense_capability: float # 0-1 scale- institutional_effectiveness: float # 0-1 scale- transatlantic_alignment: float # 0-1 scale--class DemocraticBridgeheadAgent:- """- DEMOCRATIC BRIDGEHEAD AGENT - European Strategic Analysis-- Core Thesis: Europe as America's essential ally for global leadership- - NATO expansion as strategic necessity for European stability- - European integration as American interest for power amplification- - France-Germany leadership as engine of European power- - Western Balkans integration as critical for stability-- Brzezinski Framework: Europe as anchor for American global power- """-- def __init__(self):- """Initialize the democratic bridgehead agent"""- self.agent_id = "democratic_bridgehead_agent"- self.alliance_manager = AllianceManager()- self.balance_calculator = BalanceOfPowerCalculator()-- # Critical European regions per Brzezinski- self.critical_european_regions = [- "western_europe", "central_europe", "eastern_europe",- "british_isles", "scandinavian", "southern_europe"- ]-- # Key European powers- self.key_european_powers = [- "germany", "france", "united_kingdom", "italy", "spain",- "poland", "netherlands", "sweden", "norway"- ]-- # NATO integration stages- self.nato_integration_levels = {- "full_members": ["united_states", "germany", "france", "united_kingdom", "canada"],- "recent_members": ["croatia", "montenegro", "north_macedonia", "albania"],- "aspirational_members": ["ukraine", "georgia", "bosnia", "serbia"],- "partnership_countries": ["finland", "sweden", "austria", "ireland"]- }-- def analyze_democratic_bridgehead(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for European strategic assessment-- Args:- state: AgentState containing European geopolitical data-- Returns:- Comprehensive assessment of European democratic bridgehead- """- try:- logger.info("Starting Democratic Bridgehead analysis")-- # Extract relevant data from state- european_events = state.get("european_events", [])- nato_developments = state.get("nato_developments", [])- eu_integration_data = state.get("eu_integration_data", {})- economic_indicators = state.get("european_economic_indicators", {})-- # Core Brzezinski analysis components- integration_assessment = self._assess_european_integration(eu_integration_data, european_events)- nato_assessment = self._evaluate_nato_effectiveness(nato_developments, european_events)- transatlantic_analysis = self._analyze_transatlantic_relationship(eu_integration_data, nato_developments)- regional_dynamics = self._evaluate_regional_dynamics(european_events)-- # Bridgehead effectiveness assessment- bridgehead_metrics = self._calculate_bridgehead_metrics(- integration_assessment, nato_assessment, transatlantic_analysis, regional_dynamics- )-- # Strategic opportunities and challenges- american_opportunities = self._identify_american_opportunities(- integration_assessment, nato_assessment, bridgehead_metrics- )-- strategic_challenges = self._identify_strategic_challenges(- integration_assessment, nato_assessment, regional_dynamics- )-- # Strategic recommendations- strategic_recommendations = self._generate_bridgehead_recommendations(- bridgehead_metrics, american_opportunities, strategic_challenges- )-- # Compile comprehensive assessment- bridgehead_assessment = {- "assessment_type": "democratic_bridgehead",- "timestamp": state.get("timestamp", ""),- "integration_assessment": integration_assessment,- "nato_assessment": nato_assessment,- "transatlantic_analysis": transatlantic_analysis,- "bridgehead_metrics": bridgehead_metrics,- "american_opportunities": american_opportunities,- "strategic_challenges": strategic_challenges,- "strategic_recommendations": strategic_recommendations,- "regional_dynamics": regional_dynamics,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- bridgehead_assessment,- "Democratic Bridgehead strategic analysis completed"- )-- logger.info("Democratic Bridgehead analysis completed successfully")- return bridgehead_assessment-- except Exception as e:- logger.error(f"Error in Democratic Bridgehead analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _assess_european_integration(- self,- eu_integration_data: Dict[str, Any],- european_events: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Assess current state and trajectory of European integration"""-- # Key integration dimensions- political_integration = self._assess_political_integration(eu_integration_data)- economic_integration = self._assess_economic_integration(eu_integration_data)- defense_integration = self._assess_defense_integration(eu_integration_data)- institutional_effectiveness = self._assess_institutional_effectiveness(eu_integration_data)-- # Integration trajectory- integration_events = [e for e in european_events if e.get("integration_focus")]- trajectory = self._determine_integration_trajectory(integration_events)-- # Expansion outlook- expansion_opportunities = self._identify_expansion_opportunities(european_events)- expansion_challenges = self._identify_expansion_challenges(european_events)-- # Franco-German engine assessment- franco_german_leadership = self._assess_franco_german_engine(eu_integration_data)-- return {- "overall_status": self._determine_integration_status(- political_integration, economic_integration, defense_integration- ),- "political_integration": political_integration,- "economic_integration": economic_integration,- "defense_integration": defense_integration,- "institutional_effectiveness": institutional_effectiveness,- "integration_trajectory": trajectory,- "expansion_opportunities": expansion_opportunities,- "expansion_challenges": expansion_challenges,- "franco_german_leadership": franco_german_leadership,- "key_integration_projects": self._identify_key_integration_projects(eu_integration_data),- "brexit_impact": self._assess_brexit_impact(european_events)- }-- def _evaluate_nato_effectiveness(- self,- nato_developments: List[Dict[str, Any]],- european_events: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Assess NATO's strategic effectiveness and relevance"""-- # Current NATO capabilities- military_capability = self._assess_nato_military_capability(nato_developments)- political_cohesion = self._assess_nato_political_cohesion(nato_developments)- strategic_relevance = self._assess_nato_strategic_relevance(nato_developments, european_events)-- # Expansion analysis- expansion_progress = self._analyze_nato_expansion(nato_developments)- eastern_flank_security = self._assess_eastern_flank_security(nato_developments, european_events)-- # Deterrence effectiveness- deterrence_capability = self._assess_deterrence_effectiveness(nato_developments)- rapid_response_capability = self._assess_rapid_response_capability(nato_developments)-- # Burden sharing- burden_sharing = self._analyze_nato_burden_sharing(nato_developments)-- # Modernization priorities- modernization_needs = self._identify_nato_modernization_priorities(nato_developments)-- return {- "strategic_value": self._determine_nato_strategic_value(- military_capability, political_cohesion, strategic_relevance- ),- "military_capability": military_capability,- "political_cohesion": political_cohesion,- "strategic_relevance": strategic_relevance,- "expansion_progress": expansion_progress,- "eastern_flank_security": eastern_flank_security,- "deterrence_capability": deterrence_capability,- "rapid_response_capability": rapid_response_capability,- "burden_sharing": burden_sharing,- "modernization_priorities": modernization_needs,- "key_challenges": self._identify_nato_challenges(nato_developments, european_events),- "future_direction": self._project_nato_evolution(nato_developments)- }-- def _analyze_transatlantic_relationship(- self,- eu_integration_data: Dict[str, Any],- nato_developments: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Analyze state and trajectory of transatlantic relationship"""-- # Political alignment- political_alignment = self._assess_political_alignment(eu_integration_data, nato_developments)- strategic_convergence = self._assess_strategic_convergence(eu_integration_data, nato_developments)-- # Security cooperation- security_cooperation = self._assess_security_cooperation(nato_developments)- intelligence_sharing = self._assess_intelligence_sharing(nato_developments)-- # Economic relationship- economic_partnership = self._assess_transatlantic_economic_partnership(eu_integration_data)- technological_cooperation = self._assess_technological_cooperation(eu_integration_data)-- # Institutional mechanisms- institutional_cooperation = self._assess_institutional_cooperation(eu_integration_data, nato_developments)-- # Areas of tension- policy_divergences = self._identify_transatlantic_divergences(eu_integration_data, nato_developments)- competitive_tensions = self._identify_competitive_tensions(eu_integration_data)-- return {- "overall_strength": self._calculate_transatlantic_strength(- political_alignment, strategic_convergence, security_cooperation- ),- "political_alignment": political_alignment,- "strategic_convergence": strategic_convergence,- "security_cooperation": security_cooperation,- "intelligence_sharing": intelligence_sharing,- "economic_partnership": economic_partnership,- "technological_cooperation": technological_cooperation,- "institutional_cooperation": institutional_cooperation,- "policy_divergences": policy_divergences,- "competitive_tensions": competitive_tensions,- "cooperation_opportunities": self._identify_cooperation_opportunities(),- "relationship_trajectory": self._project_relationship_trajectory()- }-- def _evaluate_regional_dynamics(self, european_events: List[Dict[str, Any]]) -> Dict[str, Any]:- """Evaluate stability and dynamics across European regions"""-- regional_assessments = {}-- for region in self.critical_european_regions:- region_events = [e for e in european_events if e.get("region") == region]-- regional_assessments[region] = {- "stability_level": self._assess_regional_stability(region_events),- "key_dynamics": self._identify_regional_dynamics(region_events),- "strategic_importance": self._assess_region_strategic_importance(region),- "american_influence": self._assess_american_regional_influence(region_events),- "challenge_areas": self._identify_regional_challenges(region_events),- "opportunity_areas": self._identify_regional_opportunities(region_events)- }-- # Cross-regional dynamics- regional_interactions = self._analyze_regional_interactions(european_events)- stability_interdependencies = self._identify_stability_interdependencies(european_events)-- return {- "regional_assessments": regional_assessments,- "regional_interactions": regional_interactions,- "stability_interdependencies": stability_interdependencies,- "critical_flashpoints": self._identify_european_flashpoints(european_events),- "stability_outlook": self._project_overall_stability(european_events),- "transatlantic_implications": self._assess_transatlantic_regional_implications(regional_assessments)- }-- def _calculate_bridgehead_metrics(- self,- integration_assessment: Dict[str, Any],- nato_assessment: Dict[str, Any],- transatlantic_analysis: Dict[str, Any],- regional_dynamics: Dict[str, Any]- ) -> BridgeheadMetrics:- """Calculate comprehensive bridgehead effectiveness metrics"""-- # Political cohesion based on EU integration and NATO cohesion- political_cohesion = (- integration_assessment.get("political_integration", 0.5) * 0.6 +- nato_assessment.get("political_cohesion", 0.5) * 0.4- )-- # Economic integration from EU assessment- economic_integration = integration_assessment.get("economic_integration", 0.5)-- # Defense capability from NATO assessment- defense_capability = (- nato_assessment.get("military_capability", 0.5) * 0.7 +- integration_assessment.get("defense_integration", 0.5) * 0.3- )-- # Institutional effectiveness- institutional_effectiveness = (- integration_assessment.get("institutional_effectiveness", 0.5) * 0.5 +- nato_assessment.get("strategic_relevance", 0.5) * 0.3 +- transatlantic_analysis.get("institutional_cooperation", 0.5) * 0.2- )-- # Transatlantic alignment- transatlantic_alignment = transatlantic_analysis.get("overall_strength", 0.5)-- return BridgeheadMetrics(- political_cohesion=political_cohesion,- economic_integration=economic_integration,- defense_capability=defense_capability,- institutional_effectiveness=institutional_effectiveness,- transatlantic_alignment=transatlantic_alignment- )-- def _identify_american_opportunities(- self,- integration_assessment: Dict[str, Any],- nato_assessment: Dict[str, Any],- bridgehead_metrics: BridgeheadMetrics- ) -> List[str]:- """Identify strategic opportunities for American engagement"""-- opportunities = []-- # Opportunities based on integration status- if integration_assessment.get("overall_status") == IntegrationStatus.DEEPENING:- opportunities.append(- "Support deeper EU integration for stronger transatlantic partnership"- )- opportunities.append(- "Engage with European strategic autonomy initiatives to maintain alignment"- )-- # NATO expansion opportunities- if nato_assessment.get("expansion_progress").get("momentum") == "positive":- opportunities.append(- "Lead NATO expansion to enhance European security architecture"- )- opportunities.append(- "Support aspirant members' NATO accession processes"- )-- # Defense cooperation opportunities- if bridgehead_metrics.defense_capability < 0.7:- opportunities.append(- "Increase American defense industry cooperation with European partners"- )- opportunities.append(- "Lead joint defense modernization initiatives"- )-- # Technology cooperation opportunities- if bridgehead_metrics.institutional_effectiveness > 0.6:- opportunities.append(- "Expand technological cooperation in critical domains like AI and quantum computing"- )- opportunities.append(- "Lead transatlantic technology standards setting"- )-- # Regional engagement opportunities- if bridgehead_metrics.political_cohesion > 0.6:- opportunities.append(- "Deepen political cooperation on global governance reforms"- )- opportunities.append(- "Coordinate approaches to global challenges like climate change and pandemics"- )-- return opportunities-- def _identify_strategic_challenges(- self,- integration_assessment: Dict[str, Any],- nato_assessment: Dict[str, Any],- regional_dynamics: Dict[str, Any]- ) -> List[str]:- """Identify strategic challenges to democratic bridgehead"""-- challenges = []-- # Integration challenges- if integration_assessment.get("overall_status") in [IntegrationStatus.STAGNATING, IntegrationStatus.FRAGMENTING]:- challenges.append(- "European integration fragmentation undermines strategic coherence"- )-- if integration_assessment.get("franco_german_leadership").get("effectiveness") < 0.6:- challenges.append(- "Weak Franco-German leadership reduces European strategic initiative"- )-- # NATO challenges- if nato_assessment.get("political_cohesion") < 0.6:- challenges.append(- "NATO political divisions reduce alliance effectiveness"- )-- if nato_assessment.get("burden_sharing").get("fairness_assessment") == "poor":- challenges.append(- "Inequitable burden sharing creates alliance tensions"- )-- # Regional stability challenges- unstable_regions = [- region for region, assessment in regional_dynamics.get("regional_assessments", {}).items()- if assessment.get("stability_level") == "unstable"- ]-- if unstable_regions:- challenges.append(- f"Regional instability in {', '.join(unstable_regions)} threatens European security"- )-- # Transatlantic challenges- divergences = regional_dynamics.get("transatlantic_implications", {}).get("divergences", [])- if divergences:- challenges.extend(divergences)-- return challenges-- def _generate_bridgehead_recommendations(- self,- metrics: BridgeheadMetrics,- opportunities: List[str],- challenges: List[str]- ) -> List[str]:- """Generate strategic recommendations for strengthening democratic bridgehead"""-- recommendations = []-- # Core bridgehead strengthening- if metrics.political_cohesion < 0.7:- recommendations.append(- "Support European political integration through enhanced transatlantic dialogue"- )- recommendations.append(- "Encourage Franco-German leadership cooperation on strategic initiatives"- )-- if metrics.defense_capability < 0.7:- recommendations.append(- "Increase American defense investment in European theater"- )- recommendations.append(- "Lead NATO modernization and capability development"- )- recommendations.append(- "Support European defense industry integration with American partners"- )-- if metrics.economic_integration < 0.7:- recommendations.append(- "Promote transatlantic economic integration and trade cooperation"- )- recommendations.append(- "Support EU single market deepening and expansion"- )-- if metrics.transatlantic_alignment < 0.7:- recommendations.append(- "Address policy divergences through enhanced diplomatic engagement"- )- recommendations.append(- "Coordinate approaches to global governance and international institutions"- )-- # Leverage opportunities- if opportunities:- recommendations.append(- "Strategic opportunity: " + opportunities[0] if opportunities else ""- )-- # Address challenges- if challenges:- recommendations.append(- "Address challenge: " + challenges[0] if challenges else ""- )-- # Eastern flank security- recommendations.append(- "Strengthen NATO's eastern flank through permanent deployments and exercises"- )- recommendations.append(- "Support security capabilities of Eastern European NATO members"- )-- # Balkans integration- recommendations.append(- "Lead Western Balkans integration into Euro-Atlantic structures"- )- recommendations.append(- "Support regional cooperation and conflict resolution in Balkans"- )-- return recommendations-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's European framework"""-- validation_criteria = {- "european_bridgehead_focus": True, # Europe as essential American ally- "nato_central_role": True, # NATO as central security institution- "integration_support": True, # European integration as American interest- "transatlantic_partnership": True, # Partnership rather than dominance- "regional_stability": True, # Stability as strategic objective- "franco_german_engine": True # France-Germany as leadership core- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "Europe as democratic bridgehead for American global power",- "NATO as essential transatlantic security framework",- "European integration as amplifier of American influence",- "Franco-German partnership as European engine",- "Eastern Europe as critical security frontier",- "Western Balkans as integration priority"- ]- }-- def _calculate_confidence_score(self, state: AgentState) -> float:- """Calculate confidence score for bridgehead assessment"""-- # Data quality assessment- data_completeness = self._assess_data_completeness(state)- data_recency = self._assess_data_recency(state)-- # Analytical clarity- regional_coverage = self._assess_regional_coverage(state)- event_relevance = self._assess_event_relevance(state)-- # Calculate weighted confidence- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- regional_coverage * 0.35 +- event_relevance * 0.25- )-- return min(confidence, 1.0)-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""-- return {- "assessment_type": "democratic_bridgehead",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Strengthen transatlantic diplomatic engagement",- "Support European integration initiatives",- "Maintain NATO alliance effectiveness",- "Monitor regional stability developments"- ],- "confidence_score": 0.0- }-- # Helper method implementations- def _assess_political_integration(self, eu_integration_data: Dict[str, Any]) -> float:- """Assess level of political integration in EU"""- # Simplified implementation - would be more sophisticated in production- policy_harmonization = eu_integration_data.get("policy_harmonization", 0.5)- institutional_development = eu_integration_data.get("institutional_development", 0.5)- citizen_support = eu_integration_data.get("citizen_european_support", 0.5)-- return (policy_harmonization + institutional_development + citizen_support) / 3-- def _assess_economic_integration(self, eu_integration_data: Dict[str, Any]) -> float:- """Assess level of economic integration"""- single_market_completion = eu_integration_data.get("single_market_completion", 0.5)- monetary_union_strength = eu_integration_data.get("monetary_union_strength", 0.5)- fiscal_coordination = eu_integration_data.get("fiscal_coordination", 0.5)-- return (single_market_completion + monetary_union_strength + fiscal_coordination) / 3-- def _assess_defense_integration(self, eu_integration_data: Dict[str, Any]) -> float:- """Assess level of defense integration"""- defense_cooperation = eu_integration_data.get("defense_cooperation", 0.5)- capability_development = eu_integration_data.get("joint_capability_development", 0.5)- operational_coordination = eu_integration_data.get("operational_coordination", 0.5)-- return (defense_cooperation + capability_development + operational_coordination) / 3-- def _assess_institutional_effectiveness(self, eu_integration_data: Dict[str, Any]) -> float:- """Assess effectiveness of EU institutions"""- institutional_efficiency = eu_integration_data.get("institutional_efficiency", 0.5)- democratic_legitimacy = eu_integration_data.get("democratic_legitimacy", 0.5)- decision_making_effectiveness = eu_integration_data.get("decision_making_effectiveness", 0.5)-- return (institutional_efficiency + democratic_legitimacy + decision_making_effectiveness) / 3-- # Additional helper methods for complete functionality- def _determine_integration_status(- self,- political: float,- economic: float,- defense: float- ) -> IntegrationStatus:- """Determine overall integration status"""- average_integration = (political + economic + defense) / 3-- if average_integration > 0.7:- return IntegrationStatus.DEEPENING- elif average_integration > 0.5:- return IntegrationStatus.EXPANDING- elif average_integration > 0.3:- return IntegrationStatus.STAGNATING- else:- return IntegrationStatus.FRAGMENTING-- def _assess_data_completeness(self, state: AgentState) -> float:- """Assess completeness of input data"""- required_fields = ["european_events", "nato_developments", "eu_integration_data"]- present_fields = sum(1 for field in required_fields if state.get(field))- return present_fields / len(required_fields)-- def _assess_data_recency(self, state: AgentState) -> float:- """Assess recency of input data"""- # Simplified implementation- return 0.8 # Assume reasonably current data-- def _assess_regional_coverage(self, state: AgentState) -> float:- """Assess regional coverage of events"""- events = state.get("european_events", [])- regions_covered = set(event.get("region") for event in events if event.get("region"))- total_regions = len(self.critical_european_regions)- return len(regions_covered) / total_regions if total_regions > 0 else 0-- def _assess_event_relevance(self, state: AgentState) -> float:- """Assess relevance of events to bridgehead analysis"""- events = state.get("european_events", [])- relevant_events = sum(1 for event in events- if event.get("integration_focus") or event.get("nato_relevance"))- return relevant_events / len(events) if events else 0--# Main agent function following existing patterns-def democratic_bridgehead_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function for European democratic bridgehead analysis-- Args:- state: AgentState with European geopolitical data-- Returns:- Strategic assessment of European democratic bridgehead- """- agent = DemocraticBridgeheadAgent()- return agent.analyze_democratic_bridgehead(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "european_events": [- {"id": "1", "type": "political", "region": "eastern_europe", "description": "Poland increases defense spending", "nato_relevance": True},- {"id": "2", "type": "economic", "region": "western_europe", "description": "EU announces new digital market regulations", "integration_focus": True},- {"id": "3", "type": "security", "region": "central_europe", "description": "Germany announces military modernization", "integration_focus": True}- ],- "nato_developments": [- {"id": "1", "type": "expansion", "description": "Finland and Sweden accession process", "status": "in_progress"},- {"id": "2", "type": "capability", "description": "Enhanced forward presence in Eastern Europe", "status": "implemented"}- ],- "eu_integration_data": {- "policy_harmonization": 0.7,- "institutional_development": 0.6,- "citizen_european_support": 0.5,- "single_market_completion": 0.8,- "monetary_union_strength": 0.6,- "fiscal_coordination": 0.4,- "defense_cooperation": 0.5,- "joint_capability_development": 0.4,- "operational_coordination": 0.6- },- "european_economic_indicators": {- "eu_growth": 1.4,- "inflation": 3.2,- "unemployment": 6.1,- "trade_balance": "surplus"- }- }-- result = democratic_bridgehead_agent(test_state)- print("Democratic Bridgehead Analysis Results:")- print(f"Integration Status: {result.get('integration_assessment', {}).get('overall_status', 'unknown')}")- print(f"NATO Strategic Value: {result.get('nato_assessment', {}).get('strategic_value', 'unknown')}")- print(f"Transatlantic Strength: {result.get('transatlantic_analysis', {}).get('overall_strength', 0):.2f}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_balkans_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_balkans_agent.pydeleted file mode 100644index 8e1282e16..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_balkans_agent.py+++ /dev/null@@ -1,761 +0,0 @@-"""-EURASIAN BALKANS AGENT-Central Asia/Caucasus Competition Analysis for Grand Chessboard Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - central_asia_events (array)-# - caucasus_events (array)-# - caspian_developments (array)-# - regional_great_power_competition (object)-# - EURASIAN_BALKANS_API_KEY-#-# OUTPUT:-# - Central Asia/Caucasus strategic assessment-# - Great power competition analysis-# - Energy route security evaluation-# - Regional stability recommendations-#-# PARAMETERS:-# - analysis_focus="great_power_competition"-# - strategic_timeframe="decade"-# - perspective="balance_management"-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator-from ..geostrategic_modules.containment_strategy import ContainmentStrategy--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class BalkansStability(Enum):- """Stability level of Eurasian Balkans"""- STABLE = "stable" # Manageable great power competition- COMPETITIVE = "competitive" # Intense but controlled competition- VOLATILE = "volatile" # Risk of great power conflict- FRAGMENTING = "fragmenting" # Regional states fragmenting- DOMINATED = "dominated" # Single power achieving dominance--class CompetitionLevel(Enum):- """Level of great power competition"""- BALANCED = "balanced" # Multiple powers with no clear leader- DOMINANT_POWER = "dominant_power" # One power clearly leading- TRANSITIONAL = "transitional" # Power balance shifting- CONTESTED = "contested" # Multiple powers competing intensely--@dataclass-class BalkansStrategicAssessment:- """Strategic assessment of Eurasian Balkans"""- stability_level: BalkansStability- competition_level: CompetitionLevel- power_distribution: Dict[str, float]- energy_route_security: float # 0-1 scale- regional_sovereignty: float # 0-1 scale- great_power_influence: Dict[str, float]- conflict_risk: str # low, medium, high, critical- strategic_recommendations: List[str]--@dataclass-class RegionalDynamics:- """Dynamics across Balkans subregions"""- central_asia_dynamics: Dict[str, Any]- caucasus_dynamics: Dict[str, Any]- caspian_dynamics: Dict[str, Any]- cross_regional_flows: Dict[str, Any]- great_power_presence: Dict[str, Dict[str, Any]]--class EurasianBalkansAgent:- """- EURASIAN BALKANS AGENT - Central Asia/Caucasus Competition Analysis-- Core Thesis: Central Asia as critical zone of great power competition- - Historical crossroads between empires with recurring conflict patterns- - Energy wealth (Caspian Sea) and resource distribution driving competition- - Ethnic complexity and state weakness creating external intervention opportunities- - Great power rivalry (Russia, China, Turkey, Iran, America) for influence- - Strategic importance of preventing any single power domination-- Brzezinski Framework: Preventing single power domination through balance management- """-- def __init__(self):- """Initialize Eurasian Balkans agent"""- self.agent_id = "eurasian_balkans_agent"- self.balance_calculator = BalanceOfPowerCalculator()- self.containment_strategist = ContainmentStrategy()-- # Eurasian Balkans subregions per Brzezinski- self.balkans_subregions = [- "central_asia", "caucasus", "caspian_region", "afghanistan_pakistan",- "western_china", "southern_russia"- ]-- # Great powers competing in Balkans- self.competing_powers = [- "russia", "china", "turkey", "iran", "united_states",- "pakistan", "india", "saudi_arabia"- ]-- # Critical states in Eurasian Balkans- self.critical_states = [- "kazakhstan", "uzbekistan", "turkmenistan", "kyrgyzstan", "tajikistan",- "azerbaijan", "georgia", "armenia", "afghanistan",- "turkmenistan", "iran", "pakistan"- ]-- # Strategic resources and routes- self.strategic_resources = [- "caspian_oil_gas", "central_asian_minerals", "silk_roads",- "energy_pipelines", "transportation_corridors", "water_resources"- ]-- # Ethnic groups causing complexity- self.ethnic_groups = [- "turkic_peoples", "persian_speakers", "russian_minorities",- "caucasian_ethnic_groups", "afghan_tribes", "central_asian_turks"- ]-- def analyze_eurasian_balkans(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for Eurasian Balkans assessment-- Args:- state: AgentState containing Balkans geopolitical data-- Returns:- Comprehensive assessment of Eurasian Balkans dynamics- """- try:- logger.info("Starting Eurasian Balkans analysis")-- # Extract relevant data from state- central_asia_events = state.get("central_asia_events", [])- caucasus_events = state.get("caucasus_events", [])- caspian_developments = state.get("caspian_developments", [])- regional_competition = state.get("regional_great_power_competition", {})-- # Core Brzezinski analysis components- regional_dynamics = self._analyze_regional_dynamics(- central_asia_events, caucasus_events, caspian_developments- )-- great_power_competition = self._analyze_great_power_competition(- regional_competition, regional_dynamics- )-- energy_politics = self._analyze_energy_politics(- caspian_developments, regional_dynamics- )-- ethnic_complexity = self._analyze_ethnic_complexity(- central_asia_events, caucasus_events, regional_dynamics- )-- strategic_assessment = self._assess_strategic_importance(- regional_dynamics, great_power_competition, energy_politics- )-- # Stability and conflict analysis- stability_assessment = self._assess_regional_stability(- regional_dynamics, great_power_competition, ethnic_complexity- )-- # Strategic opportunities and threats- great_power_opportunities = self._identify_great_power_opportunities(- great_power_competition, energy_politics, regional_dynamics- )-- regional_vulnerabilities = self._identify_regional_vulnerabilities(- stability_assessment, great_power_competition, ethnic_complexity- )-- # Strategic recommendations- strategic_recommendations = self._generate_balkans_recommendations(- strategic_assessment, stability_assessment, great_power_opportunities,- regional_vulnerabilities- )-- # Compile comprehensive assessment- balkans_assessment = {- "assessment_type": "eurasian_balkans",- "timestamp": state.get("timestamp", ""),- "regional_dynamics": regional_dynamics,- "great_power_competition": great_power_competition,- "energy_politics": energy_politics,- "ethnic_complexity": ethnic_complexity,- "strategic_assessment": strategic_assessment,- "stability_assessment": stability_assessment,- "great_power_opportunities": great_power_opportunities,- "regional_vulnerabilities": regional_vulnerabilities,- "strategic_recommendations": strategic_recommendations,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- balkans_assessment,- "Eurasian Balkans strategic analysis completed"- )-- logger.info("Eurasian Balkans analysis completed successfully")- return balkans_assessment-- except Exception as e:- logger.error(f"Error in Eurasian Balkans analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _analyze_regional_dynamics(- self,- central_asia_events: List[Dict[str, Any]],- caucasus_events: List[Dict[str, Any]],- caspian_developments: List[Dict[str, Any]]- ) -> RegionalDynamics:- """Analyze dynamics across Eurasian Balkans subregions"""-- # Central Asia dynamics- central_asia_dynamics = self._analyze_central_asia_dynamics(central_asia_events)-- # Caucasus dynamics- caucasus_dynamics = self._analyze_caucasus_dynamics(caucasus_events)-- # Caspian Sea dynamics- caspian_dynamics = self._analyze_caspian_dynamics(caspian_developments)-- # Cross-regional flows and connections- cross_regional_flows = self._analyze_cross_regional_flows(- central_asia_events, caucasus_events, caspian_developments- )-- # Great power military and economic presence- great_power_presence = self._analyze_great_power_presence(- central_asia_events, caucasus_events, caspian_developments- )-- return RegionalDynamics(- central_asia_dynamics=central_asia_dynamics,- caucasus_dynamics=caucasus_dynamics,- caspian_dynamics=caspian_dynamics,- cross_regional_flows=cross_regional_flows,- great_power_presence=great_power_presence- )-- def _analyze_great_power_competition(- self,- regional_competition: Dict[str, Any],- regional_dynamics: RegionalDynamics- ) -> Dict[str, Any]:- """Analyze competition among great powers in Eurasian Balkans"""-- # Current power distribution- power_distribution = self._calculate_power_distribution(- regional_competition, regional_dynamics- )-- # Competition intensity by region- regional_competition = {}- for subregion in self.balkans_subregions:- regional_competition[subregion] = self._assess_regional_competition(- subregion, regional_dynamics- )-- # Competition dynamics and trends- competition_trends = self._analyze_competition_trends(- power_distribution, regional_dynamics- )-- # Emerging dominance patterns- dominance_patterns = self._identify_dominance_patterns(- power_distribution, regional_competition- )-- # Strategic alignments and partnerships- regional_alignments = self._analyze_regional_alignments(- regional_dynamics, power_distribution- )-- # Competition areas and domains- competition_domains = self._identify_competition_domains(- regional_competition, regional_dynamics- )-- return {- "power_distribution": power_distribution,- "regional_competition": regional_competition,- "competition_trends": competition_trends,- "dominance_patterns": dominance_patterns,- "regional_alignments": regional_alignments,- "competition_domains": competition_domains,- "competition_level": self._determine_overall_competition_level(- power_distribution, regional_competition- ),- "critical_points": self._identify_competition_critical_points(- power_distribution, regional_dynamics- )- }-- def _analyze_energy_politics(- self,- caspian_developments: List[Dict[str, Any]],- regional_dynamics: RegionalDynamics- ) -> Dict[str, Any]:- """Analyze energy politics and resource competition"""-- # Caspian Sea resource politics- caspian_resources = self._analyze_caspian_resources(caspian_developments)-- # Energy route competition- pipeline_politics = self._analyze_pipeline_politics(caspian_developments)- transportation_corridors = self._analyze_transportation_corridors(- caspian_developments, regional_dynamics- )-- # Resource access and control- resource_control = self._analyze_resource_control(- caspian_developments, regional_dynamics- )-- # Energy security implications- energy_security_impact = self._assess_energy_security_impact(- caspian_resources, pipeline_politics, resource_control- )-- # Great power energy strategies- energy_strategies = self._analyze_great_power_energy_strategies(- caspian_developments, regional_dynamics- )-- return {- "caspian_resources": caspian_resources,- "pipeline_politics": pipeline_politics,- "transportation_corridors": transportation_corridors,- "resource_control": resource_control,- "energy_security_impact": energy_security_impact,- "great_power_energy_strategies": energy_strategies,- "energy_route_vulnerabilities": self._identify_energy_route_vulnerabilities(),- "energy_independence_prospects": self._assess_energy_independence_prospects()- }-- def _analyze_ethnic_complexity(- self,- central_asia_events: List[Dict[str, Any]],- caucasus_events: List[Dict[str, Any]],- regional_dynamics: RegionalDynamics- ) -> Dict[str, Any]:- """Analyze ethnic complexity and its impact on regional stability"""-- # Ethnic group distribution and dynamics- ethnic_distribution = self._analyze_ethnic_distribution(- central_asia_events, caucasus_events- )-- # Ethnic conflicts and tensions- ethnic_tensions = self._identify_ethnic_tensions(- central_asia_events, caucasus_events- )-- # Great power exploitation of ethnic divisions- external_exploitation = self._analyze_external_exploitation(- ethnic_tensions, regional_dynamics.great_power_presence- )-- # State weakness due to ethnic divisions- state_fragmentation_risk = self._assess_state_fragmentation_risk(- ethnic_distribution, ethnic_tensions- )-- # Cross-border ethnic connections- cross_border_ethnicity = self._analyze_cross_border_ethnicity(- ethnic_distribution, central_asia_events, caucasus_events- )-- # Ethnic identity and nationalism trends- nationalist_movements = self._analyze_nationalist_movements(- central_asia_events, caucasus_events- )-- return {- "ethnic_distribution": ethnic_distribution,- "ethnic_tensions": ethnic_tensions,- "external_exploitation": external_exploitation,- "state_fragmentation_risk": state_fragmentation_risk,- "cross_border_ethnicity": cross_border_ethnicity,- "nationalist_movements": nationalist_movements,- "ethnic_stability_factors": self._identify_ethnic_stability_factors(),- "ethnic_conflict_triggers": self._identify_ethnic_conflict_triggers()- }-- def _assess_strategic_importance(- self,- regional_dynamics: RegionalDynamics,- great_power_competition: Dict[str, Any],- energy_politics: Dict[str, Any]- ) -> BalkansStrategicAssessment:- """Assess overall strategic importance of Eurasian Balkans"""-- # Stability assessment- stability_factors = self._calculate_stability_factors(- regional_dynamics, great_power_competition- )- stability_level = self._determine_stability_level(stability_factors)-- # Competition level assessment- competition_intensity = self._assess_competition_intensity(- great_power_competition- )- competition_level = self._determine_competition_level(competition_intensity)-- # Power distribution analysis- power_distribution = great_power_competition.get("power_distribution", {})-- # Energy route security assessment- energy_security = energy_politics.get("energy_security_impact", 0.5)-- # Regional sovereignty assessment- regional_sovereignty = self._assess_regional_sovereignty(- great_power_competition, regional_dynamics- )-- # Great power influence mapping- great_power_influence = great_power_competition.get("power_distribution", {})-- # Conflict risk assessment- conflict_risk = self._assess_conflict_risk(- stability_level, competition_level, great_power_competition- )-- # Strategic recommendations- strategic_recommendations = self._generate_strategic_recommendations(- stability_level, competition_level, power_distribution- )-- return BalkansStrategicAssessment(- stability_level=stability_level,- competition_level=competition_level,- power_distribution=power_distribution,- energy_route_security=energy_security,- regional_sovereignty=regional_sovereignty,- great_power_influence=great_power_influence,- conflict_risk=conflict_risk,- strategic_recommendations=strategic_recommendations- )-- def _generate_balkans_recommendations(- self,- strategic_assessment: BalkansStrategicAssessment,- stability_assessment: Dict[str, Any],- opportunities: List[str],- vulnerabilities: List[str]- ) -> List[str]:- """Generate strategic recommendations for Eurasian Balkans"""-- recommendations = []-- # Stability and balance recommendations- if strategic_assessment.stability_level in [BalkansStability.VOLATILE, BalkansStability.FRAGMENTING]:- recommendations.append(- "Prevent single power domination through balanced great power engagement"- )- recommendations.append(- "Support regional sovereignty and state stability through diplomatic engagement"- )- recommendations.append(- "Coordinate great power behavior through multilateral frameworks"- )-- # Competition management recommendations- if strategic_assessment.competition_level == CompetitionLevel.CONTESTED:- recommendations.append(- "Establish clear rules of engagement for great power competition"- )- recommendations.append(- "Create regional security architecture to manage competition"- )-- # Energy security recommendations- if strategic_assessment.energy_route_security < 0.6:- recommendations.append(- "Ensure energy route security through international cooperation"- )- recommendations.append(- "Develop alternative energy routes to reduce vulnerability"- )-- # Great power management recommendations- dominant_power = max(strategic_assessment.great_power_influence.items(), key=lambda x: x[1])- if dominant_power[1] > 0.4:- recommendations.append(- f"Balance {dominant_power[0].title()}'s growing influence in the region"- )-- # Regional cooperation recommendations- recommendations.extend([- "Promote regional economic integration to reduce external dependence",- "Support conflict resolution mechanisms for ethnic disputes",- "Encourage regional cooperation on counter-terrorism and security",- "Develop infrastructure projects that benefit multiple countries"- ])-- # Exploit opportunities- if opportunities:- recommendations.extend(opportunities[:3])-- # Address vulnerabilities- if vulnerabilities:- recommendations.extend(vulnerabilities[:3])-- return recommendations-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's Eurasian Balkans framework"""-- validation_criteria = {- "balkans_recognition": True, # Central Asia/Caucasus as critical zone- "great_power_competition": True, # Multiple powers competing for influence- "balance_management": True, # Preventing single power dominance- "energy_politics_focus": True, # Energy resources as key driver- "ethnic_complexity": True, # Ethnic diversity as stability factor- "strategic_containment": True, # Great power containment through balance- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "Central Asia/Caucasus as Eurasian Balkans competition zone",- "Great power competition requiring balance management",- "Energy politics as primary driver of regional dynamics",- "Ethnic complexity creating external intervention opportunities",- "Prevention of single power domination as strategic imperative",- "Regional stability through balanced great power engagement"- ]- }-- def _calculate_confidence_score(self, state: AgentState) -> float:- """Calculate confidence score for Balkans assessment"""-- # Data quality assessment- data_completeness = self._assess_data_completeness(state)- data_recency = self._assess_data_recency(state)-- # Analytical clarity- regional_coverage = self._assess_regional_coverage(state)- event_relevance = self._assess_event_relevance(state)-- # Calculate weighted confidence- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- regional_coverage * 0.35 +- event_relevance * 0.25- )-- return min(confidence, 1.0)-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""-- return {- "assessment_type": "eurasian_balkans",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Maintain balanced engagement with all regional powers",- "Support regional sovereignty and stability",- "Prevent any single power from achieving dominance",- "Promote regional economic cooperation and integration"- ],- "confidence_score": 0.0- }-- # Helper method implementations- def _analyze_central_asia_dynamics(self, events: List[Dict[str, Any]]) -> Dict[str, Any]:- """Analyze Central Asian dynamics"""- return {- "political_stability": 0.6,- "economic_development": 0.5,- "external_influence": 0.7,- "regional_cooperation": 0.4,- "security_situation": 0.5- }-- def _analyze_caucasus_dynamics(self, events: List[Dict[str, Any]]) -> Dict[str, Any]:- """Analyze Caucasus dynamics"""- return {- "conflict_intensity": 0.7,- "external_competition": 0.8,- "ethnic_tensions": 0.6,- "strategic_importance": 0.9,- "state_effectiveness": 0.4- }-- def _analyze_caspian_dynamics(self, developments: List[Dict[str, Any]]) -> Dict[str, Any]:- """Analyze Caspian Sea dynamics"""- return {- "resource_competition": 0.8,- "route_security": 0.5,- "legal_disputes": 0.7,- "strategic_value": 0.9,- "international_cooperation": 0.4- }-- def _analyze_cross_regional_flows(- self,- central_asia: List[Dict[str, Any]],- caucasus: List[Dict[str, Any]],- caspian: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Analyze cross-regional flows and connections"""- return {- "trade_flows": {"strength": 0.6, "directions": ["north-south", "east-west"]},- "energy_flows": {"strength": 0.8, "critical_routes": ["pipelines", "shipping"]},- "people_flows": {"strength": 0.5, "migration_patterns": ["labor", "refugee"]},- "influence_flows": {"strength": 0.7, "external_powers": ["russia", "china", "turkey", "iran"]}- }-- def _analyze_great_power_presence(- self,- central_asia: List[Dict[str, Any]],- caucasus: List[Dict[str, Any]],- caspian: List[Dict[str, Any]]- ) -> Dict[str, Dict[str, Any]]:- """Analyze great power presence across regions"""- return {- "russia": {"military": 0.7, "economic": 0.6, "political": 0.8},- "china": {"military": 0.5, "economic": 0.8, "political": 0.7},- "turkey": {"military": 0.3, "economic": 0.5, "political": 0.6},- "iran": {"military": 0.4, "economic": 0.4, "political": 0.5},- "united_states": {"military": 0.3, "economic": 0.5, "political": 0.4}- }-- def _calculate_power_distribution(- self,- competition_data: Dict[str, Any],- dynamics: RegionalDynamics- ) -> Dict[str, float]:- """Calculate power distribution among competing powers"""- presence = dynamics.great_power_presence- power_distribution = {}-- for power, presence_data in presence.items():- # Calculate composite power score- composite_power = (- presence_data.get("military", 0) * 0.3 +- presence_data.get("economic", 0) * 0.3 +- presence_data.get("political", 0) * 0.4- )- power_distribution[power] = composite_power-- return power_distribution-- def _determine_stability_level(self, factors: Dict[str, float]) -> BalkansStability:- """Determine overall stability level"""- average_stability = sum(factors.values()) / len(factors)-- if average_stability > 0.7:- return BalkansStability.STABLE- elif average_stability > 0.5:- return BalkansStability.COMPETITIVE- elif average_stability > 0.3:- return BalkansStability.VOLATILE- else:- return BalkansStability.FRAGMENTING-- def _determine_competition_level(self, intensity: float) -> CompetitionLevel:- """Determine competition level based on intensity"""- if intensity > 0.7:- return CompetitionLevel.CONTESTED- elif intensity > 0.5:- return CompetitionLevel.TRANSITIONAL- elif intensity > 0.3:- return CompetitionLevel.BALANCED- else:- return CompetitionLevel.DOMINANT_POWER-- # Additional helper methods for complete functionality- def _assess_data_completeness(self, state: AgentState) -> float:- """Assess completeness of input data"""- required_fields = ["central_asia_events", "caucasus_events", "caspian_developments"]- present_fields = sum(1 for field in required_fields if state.get(field))- return present_fields / len(required_fields)-- def _assess_data_recency(self, state: AgentState) -> float:- """Assess recency of input data"""- return 0.8 # Assume reasonably current data-- def _assess_regional_coverage(self, state: AgentState) -> float:- """Assess regional coverage of events"""- all_events = (state.get("central_asia_events", []) +- state.get("caucasus_events", []) +- state.get("caspian_developments", []))- regions_covered = len(all_events) > 0- return 1.0 if regions_covered else 0.0-- def _assess_event_relevance(self, state: AgentState) -> float:- """Assess relevance of events to Balkans analysis"""- all_events = (state.get("central_asia_events", []) +- state.get("caucasus_events", []) +- state.get("caspian_developments", []))- relevant_events = len(all_events) # All events assumed relevant- return min(relevant_events / max(1, len(all_events)), 1.0)--# Main agent function following existing patterns-def eurasian_balkans_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function for Eurasian Balkans analysis-- Args:- state: AgentState with Balkans geopolitical data-- Returns:- Strategic assessment of Eurasian Balkans dynamics- """- agent = EurasianBalkansAgent()- return agent.analyze_eurasian_balkans(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "central_asia_events": [- {"id": "1", "type": "political", "description": "Kazakhstan reforms energy policy", "external_involvement": True},- {"id": "2", "type": "economic", "description": "China invests in Central Asian infrastructure", "great_power_interest": True}- ],- "caucasus_events": [- {"id": "1", "type": "conflict", "description": "Azerbaijan-Armenia tensions increase", "ethnic_component": True},- {"id": "2", "type": "geopolitical", "description": "Russia maintains military presence", "strategic_importance": True}- ],- "caspian_developments": [- {"id": "1", "type": "energy", "description": "New Caspian Sea drilling agreements", "resource_competition": True},- {"id": "2", "type": "infrastructure", "description": "Pipeline route negotiations", "strategic_infrastructure": True}- ],- "regional_great_power_competition": {- "russian_influence": "maintaining_presence",- "chinese_expansion": "economic_penetration",- "turkish_ambitions": "regional_leadership",- "iranian_interests": "energy_security"- }- }-- result = eurasian_balkans_agent(test_state)- print("Eurasian Balkans Analysis Results:")- print(f"Stability Level: {result.get('stability_assessment', {}).get('stability_level', 'unknown')}")- print(f"Competition Level: {result.get('strategic_assessment', {}).get('competition_level', 'unknown')}")- print(f"Energy Route Security: {result.get('strategic_assessment', {}).get('energy_route_security', 0):.2f}")- print(f"Conflict Risk: {result.get('strategic_assessment', {}).get('conflict_risk', 'unknown')}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_chessboard_master_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_chessboard_master_agent.pydeleted file mode 100644index 8df1d8627..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/eurasian_chessboard_master_agent.py+++ /dev/null@@ -1,631 +0,0 @@-"""-EURASIAN CHESSBOARD MASTER AGENT-Zbigniew Brzezinski's Grand Strategic Framework Implementation--===== DATA SOURCES REQUIRED =====-# INPUT:-# - eurasian_events (array)-# - strategic_moves_by_powers (object)-# - military_deployments (array)-# - economic_indicators (object)-# - CHESSBOARD_API_KEY-#-# OUTPUT:-# - Strategic balance assessment-# - Primacy maintenance recommendations-# - Great power competition analysis-# - Regional stability predictions-#-# PARAMETERS:-# - analysis_depth="grand_strategic"-# - time_horizon="decade"-# - perspective="american_primacy"-"""--import logging-from typing import Dict, List, Any, Optional-from dataclasses import dataclass--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator-from ..geostrategic_modules.containment_strategy import ContainmentStrategy-from ..geostrategic_modules.alliance_management import AllianceManager-from ..geostrategic_modules.primacy_calculations import PrimacyAssessment--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--@dataclass-class StrategicAssessment:- """Data structure for strategic assessment results"""- event_id: str- timestamp: str- primacy_impact: str # positive, negative, neutral- hegemony_risk: str # high, medium, low- regional_stability: str # stable, unstable, critical- strategic_recommendations: List[str]- power_balance_shift: Dict[str, float]- confidence_score: float--@dataclass-class EurasianChessboardState:- """Current state of the Eurasian chessboard"""- global_power_distribution: Dict[str, float]- regional_dynamics: Dict[str, Dict]- strategic_priorities: List[str]- threat_assessments: Dict[str, str]- alliance_structures: Dict[str, List[str]]- critical_regions: List[str]--class EurasianChessboardMasterAgent:- """- EURASIAN CHESSBOARD MASTER AGENT - Brzezinski's Grand Strategic Framework-- Core Thesis: America must manage Eurasian competition to maintain global primacy- - Prevent emergence of single Eurasian hegemon- - Maintain balance of power through strategic engagement- - Use alliance system rather than direct control- - Focus on critical regions and pivot states-- Brzezinski Compliance Required: Grand strategic perspective, American primacy focus- """-- def __init__(self):- """Initialize the master agent with analytical capabilities"""- self.agent_id = "eurasian_chessboard_master"- self.balance_calculator = BalanceOfPowerCalculator()- self.containment_strategist = ContainmentStrategy()- self.alliance_manager = AllianceManager()- self.primacy_assessor = PrimacyAssessment()-- # Brzezinski's critical regions- self.critical_regions = [- "europe", "russia_near_abroad", "central_asia",- "east_asia", "middle_east", "south_asia"- ]-- # Geostrategic players per Brzezinski- self.geostrategic_players = [- "united_states", "france", "germany", "russia",- "china", "india", "japan"- ]-- # Geopolitical pivots per Brzezinski- self.geopolitical_pivots = [- "ukraine", "turkey", "iran", "azerbaijan", "south_korea"- ]-- def analyze_eurasian_chessboard(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for Eurasian strategic assessment-- Args:- state: AgentState containing current geopolitical data-- Returns:- Comprehensive strategic assessment with recommendations- """- try:- logger.info("Starting Eurasian Chessboard master analysis")-- # Extract relevant data from state- current_events = state.get("current_events", [])- strategic_moves = state.get("strategic_moves_by_powers", {})- military_deployments = state.get("military_deployments", [])- economic_indicators = state.get("economic_indicators", {})-- # Initialize chessboard state- chessboard_state = self._initialize_chessboard_state(- current_events, strategic_moves, economic_indicators- )-- # Core Brzezinski analysis components- primacy_assessment = self._assess_american_primacy(chessboard_state)- hegemony_analysis = self._analyze_hegemony_risks(chessboard_state)- regional_dynamics = self._evaluate_regional_dynamics(chessboard_state)- alliance_analysis = self._assess_alliance_structures(chessboard_state)-- # Strategic recommendations- strategic_recommendations = self._generate_strategic_recommendations(- primacy_assessment, hegemony_analysis, regional_dynamics, alliance_analysis- )-- # Long-term outlook- future_scenarios = self._project_future_scenarios(chessboard_state)-- # Compile comprehensive assessment- master_assessment = {- "assessment_type": "eurasian_chessboard_master",- "timestamp": state.get("timestamp", ""),- "primacy_assessment": primacy_assessment,- "hegemony_analysis": hegemony_analysis,- "regional_dynamics": regional_dynamics,- "alliance_analysis": alliance_analysis,- "strategic_recommendations": strategic_recommendations,- "future_scenarios": future_scenarios,- "chessboard_state": chessboard_state,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(chessboard_state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- master_assessment,- "Eurasian Chessboard master strategic analysis completed"- )-- logger.info("Eurasian Chessboard master analysis completed successfully")- return master_assessment-- except Exception as e:- logger.error(f"Error in Eurasian Chessboard master analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _initialize_chessboard_state(- self,- events: List[Dict],- moves: Dict[str, Any],- economics: Dict[str, Any]- ) -> EurasianChessboardState:- """Initialize the current state of the Eurasian chessboard"""-- # Calculate global power distribution- power_distribution = self.balance_calculator.calculate_global_power_balance(- military_data=moves.get("military_moves", {}),- economic_data=economics,- diplomatic_data=moves.get("diplomatic_moves", {})- )-- # Assess regional dynamics- regional_dynamics = {}- for region in self.critical_regions:- region_events = [e for e in events if e.get("region") == region]- regional_dynamics[region] = {- "stability": self._assess_regional_stability(region_events),- "power_shifts": self._identify_power_shifts(region_events),- "conflict_risk": self._calculate_conflict_risk(region_events),- "strategic_importance": self._evaluate_strategic_importance(region)- }-- # Set strategic priorities based on Brzezinski framework- strategic_priorities = [- "Prevent emergence of single Eurasian hegemon",- "Maintain American global primacy",- "Strengthen democratic bridgehead in Europe",- "Manage Russian resurgence through containment",- "Balance China's rise through regional engagement",- "Prevent domination of Eurasian Balkans",- "Maintain stability in Far Eastern anchor"- ]-- # Assess threats to American primacy- threat_assessments = {- "china_rise": self._assess_china_threat_level(power_distribution),- "russia_resurgence": self._assess_russia_threat_level(power_distribution),- "regional_conflict": self._assess_regional_conflict_threats(regional_dynamics),- "alliance_erosion": self._assess_alliance_threats(moves.get("diplomatic_moves", {}))- }-- return EurasianChessboardState(- global_power_distribution=power_distribution,- regional_dynamics=regional_dynamics,- strategic_priorities=strategic_priorities,- threat_assessments=threat_assessments,- alliance_structures=moves.get("alliances", {}),- critical_regions=self.critical_regions- )-- def _assess_american_primacy(self, chessboard_state: EurasianChessboardState) -> Dict[str, Any]:- """Assess the current state and prospects of American global primacy"""-- primacy_metrics = self.primacy_assessor.evaluate_american_primacy(- chessboard_state.global_power_distribution,- chessboard_state.alliance_structures,- chessboard_state.regional_dynamics- )-- return {- "current_status": primacy_metrics["current_status"],- "military_advantage": primacy_metrics["military_supremacy"],- "economic_leadership": primacy_metrics["economic_dominance"],- "technological_edge": primacy_metrics["technological_superiority"],- "alliance_network": primacy_metrics["alliance_strength"],- "challenges": primacy_metrics["primacy_challenges"],- "opportunities": primacy_metrics["primacy_opportunities"],- "ten_year_outlook": primacy_metrics["future_projection"]- }-- def _analyze_hegemony_risks(self, chessboard_state: EurasianChessboardState) -> Dict[str, Any]:- """Analyze risks of single power hegemony emergence in Eurasia"""-- hegemony_risks = {}-- # Assess China's regional hegemony potential- china_power = chessboard_state.global_power_distribution.get("china", 0)- china_influence = self._calculate_regional_influence("china", chessboard_state)-- hegemony_risks["china"] = {- "current_power_level": china_power,- "regional_influence": china_influence,- "hegemony_probability": self._calculate_hegemony_probability(china_power, china_influence),- "containment_requirements": self.containment_strategist.develop_china_containment(),- "critical_leverage_points": self._identify_china_vulnerabilities()- }-- # Assess Russia's regional resurgence potential- russia_power = chessboard_state.global_power_distribution.get("russia", 0)- russia_influence = self._calculate_regional_influence("russia", chessboard_state)-- hegemony_risks["russia"] = {- "current_power_level": russia_power,- "regional_influence": russia_influence,- "hegemony_probability": self._calculate_hegemony_probability(russia_power, russia_influence),- "containment_requirements": self.containment_strategist.develop_russia_containment(),- "critical_leverage_points": self._identify_russia_vulnerabilities()- }-- # Assess potential EU-led hegemony- eu_power = (- chessboard_state.global_power_distribution.get("france", 0) +- chessboard_state.global_power_distribution.get("germany", 0)- )- eu_cohesion = self._assess_european_cohesion(chessboard_state)-- hegemony_risks["european_union"] = {- "current_power_level": eu_power,- "political_cohesion": eu_cohesion,- "hegemony_probability": self._calculate_eu_hegemony_probability(eu_power, eu_cohesion),- "strategic_alignment": self._assess_eu_us_alignment(),- "critical_considerations": self._identify_eu_strategic_factors()- }-- return {- "overall_hegemony_risk": self._calculate_overall_hegemony_risk(hegemony_risks),- "power_specific_risks": hegemony_risks,- "critical_thresholds": self._define_hegemony_thresholds(),- "prevention_strategies": self._develop_hegemony_prevention_strategies()- }-- def _evaluate_regional_dynamics(self, chessboard_state: EurasianChessboardState) -> Dict[str, Any]:- """Evaluate strategic dynamics across critical Eurasian regions"""-- regional_analysis = {}-- for region in self.critical_regions:- region_data = chessboard_state.regional_dynamics.get(region, {})-- regional_analysis[region] = {- "stability_assessment": region_data.get("stability", "unknown"),- "power_shifts": region_data.get("power_shifts", []),- "conflict_potential": region_data.get("conflict_risk", "medium"),- "strategic_importance": region_data.get("strategic_importance", "high"),- "american_interests": self._identify_american_interests(region),- "great_power_competition": self._assess_great_power_competition(region, chessboard_state),- "strategic_recommendations": self._generate_regional_recommendations(region, region_data)- }-- return {- "regional_assessments": regional_analysis,- "cross_regional_dynamics": self._analyze_cross_regional_interactions(),- "critical_flashpoints": self._identify_potential_flashpoints(),- "strategic_priorities": self._rank_regional_priorities(regional_analysis)- }-- def _assess_alliance_structures(self, chessboard_state: EurasianChessboardState) -> Dict[str, Any]:- """Assess the status and effectiveness of alliance structures"""-- alliance_analysis = {}-- # NATO assessment- alliance_analysis["nato"] = {- "cohesion_level": self._assess_nato_cohesion(),- "expansion_potential": self._evaluate_nato_expansion_opportunities(),- "strategic_effectiveness": self._assess_nato_strategic_value(),- "burden_sharing": self._evaluate_nato_burden_sharing(),- "challenges": self._identify_nato_challenges()- }-- # US alliance network in Asia- alliance_analysis["asian_alliances"] = {- "japan_partnership": self._assess_us_japan_alliance(),- "south_korea_partnership": self._assess_us_skorea_alliance(),- "southeast_asia_engagement": self._assess_sea_engagement(),- "quad_effectiveness": self._assess_quad_partnership(),- "overall_strength": self._evaluate_asian_alliance_network()- }-- # Emerging partnerships- alliance_analysis["strategic_partnerships"] = {- "india_strategic_partnership": self._assess_india_partnership(),- "middle_east_alliances": self._assess_me_alliances(),- "african_engagement": self._assess_african_partnerships(),- "latin_american_relations": self._assess_latin_american_relations()- }-- return {- "alliance_structures": alliance_analysis,- "overall_strength": self._calculate_overall_alliance_strength(alliance_analysis),- "improvement_opportunities": self._identify_alliance_improvements(),- "strategic_recommendations": self._generate_alliance_recommendations()- }-- def _generate_strategic_recommendations(- self,- primacy: Dict[str, Any],- hegemony: Dict[str, Any],- regional: Dict[str, Any],- alliances: Dict[str, Any]- ) -> List[str]:- """Generate comprehensive strategic recommendations based on analysis"""-- recommendations = []-- # Primacy maintenance recommendations- if primacy.get("current_status") == "challenged":- recommendations.extend([- "Increase defense spending to maintain military technological edge",- "Strengthen economic competitiveness through innovation and trade",- "Enhance alliance network through deeper burden sharing integration"- ])-- # Hegemony prevention recommendations- high_risk_powers = [power for power, risk_data in hegemony.get("power_specific_risks", {}).items()- if risk_data.get("hegemony_probability", 0) > 0.6]-- for power in high_risk_powers:- if power == "china":- recommendations.extend([- "Strengthen Quad partnership with Japan, India, Australia",- "Enhance forward presence in Indo-Pacific theater",- "Develop economic alternatives to Belt and Road Initiative"- ])- elif power == "russia":- recommendations.extend([- "Maintain sanctions pressure on Russian military-industrial complex",- "Support Eastern European NATO members' defense capabilities",- "Engage Central Asian states to reduce Russian influence"- ])-- # Regional stability recommendations- critical_regions = [region for region, data in regional.get("regional_assessments", {}).items()- if data.get("conflict_potential") == "high"]-- for region in critical_regions:- if region == "east_asia":- recommendations.append("Enhance Taiwan Strait stability through diplomatic engagement")- elif region == "russia_near_abroad":- recommendations.append("Support sovereignty of countries in Russia's near abroad")- elif region == "middle_east":- recommendations.append("Balance regional powers while maintaining energy security")-- # Alliance strengthening recommendations- if alliances.get("overall_strength", 0) < 0.7:- recommendations.extend([- "Deepen transatlantic cooperation with European partners",- "Expand engagement with Indo-Pacific democratic partners",- "Develop new strategic partnerships with emerging powers"- ])-- return recommendations-- def _project_future_scenarios(self, chessboard_state: EurasianChessboardState) -> Dict[str, Any]:- """Project likely future scenarios for Eurasian strategic landscape"""-- scenarios = {}-- # Scenario 1: Continued American Primacy- scenarios["american_primacy_continues"] = {- "probability": self._calculate_primacy_continuation_probability(),- "key_conditions": [- "Maintain technological and military advantages",- "Strengthen alliance network effectiveness",- "Manage great power competition through strategic engagement"- ],- "strategic_implications": "Global stability maintained through American leadership",- "critical_actions": [- "Sustain defense innovation investment",- "Deepen alliance partnerships",- "Engage constructively with rising powers"- ]- }-- # Scenario 2: Chinese Regional Hegemony- scenarios["china_regional_hegemony"] = {- "probability": self._calculate_china_hegemony_probability(),- "key_conditions": [- "American disengagement from Indo-Pacific",- "Chinese military modernization success",- "Regional economic integration under Chinese leadership"- ],- "strategic_implications": "Challenge to American primacy and global order",- "critical_actions": [- "Strengthen regional alliance structures",- "Maintain forward military presence",- "Develop economic alternatives for regional partners"- ]- }-- # Scenario 3: Multipolar Competition- scenarios["multipolar_competition"] = {- "probability": self._calculate_multipolar_probability(),- "key_conditions": [- "Rise of multiple regional powers",- "American relative decline in absolute terms",- "Increased great power competition"- ],- "strategic_implications": "More complex but potentially stable competitive order",- "critical_actions": [- "Develop flexible alliance structures",- "Focus on diplomatic engagement and conflict prevention",- "Maintain strategic advantages in key domains"- ]- }-- return {- "plausible_scenarios": scenarios,- "most_likely_outcome": self._identify_most_likely_scenario(scenarios),- "strategic_preparation": self._recommend_scenario_preparation(scenarios)- }-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's theoretical framework"""-- validation_criteria = {- "eurasian_focus": True, # Analysis focuses on Eurasian continent- "primacy_maintenance": True, # American primacy is central concern- "hegemony_prevention": True, # Preventing single hegemon is key objective- "balance_management": True, # Emphasis on balance of power- "historical_continuity": True, # Recognition of historical patterns- "alliance_utilization": True, # Use of alliances rather than direct control- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "Eurasia as central chessboard",- "America as first global superpower",- "Prevention of regional hegemons",- "Balance of power management",- "Strategic alliance utilization"- ]- }-- def _calculate_confidence_score(self, chessboard_state: EurasianChessboardState) -> float:- """Calculate confidence score for the strategic assessment"""-- # Data quality factors- data_completeness = self._assess_data_completeness(chessboard_state)- data_recency = self._assess_data_recency(chessboard_state)-- # Analytical clarity factors- strategic_clarity = self._assess_strategic_situation_clarity(chessboard_state)- historical_patterns = self._assess_historical_pattern_relevance()-- # Calculate weighted confidence score- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- strategic_clarity * 0.35 +- historical_patterns * 0.25- )-- return min(confidence, 1.0)-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""-- return {- "assessment_type": "eurasian_chessboard_master",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Strengthen intelligence gathering on Eurasian developments",- "Enhance analytical capabilities for great power competition",- "Maintain flexibility in strategic planning"- ],- "confidence_score": 0.0- }-- # Helper methods (implementation details for specific analytical functions)- def _assess_regional_stability(self, events: List[Dict]) -> str:- """Assess stability level for a region based on events"""- if not events:- return "stable"-- conflict_events = [e for e in events if e.get("type") == "conflict"]- if len(conflict_events) > 2:- return "unstable"- elif len(conflict_events) > 0:- return "tense"- else:- return "stable"-- def _identify_power_shifts(self, events: List[Dict]) -> List[Dict]:- """Identify significant power shifts in regional events"""- power_shifts = []- for event in events:- if event.get("power_shift", False):- power_shifts.append(event)- return power_shifts-- def _calculate_conflict_risk(self, events: List[Dict]) -> str:- """Calculate conflict risk based on regional events"""- if not events:- return "low"-- escalation_events = [e for e in events if e.get("escalation_risk", "low") != "low"]- if len(escalation_events) > 2:- return "high"- elif len(escalation_events) > 0:- return "medium"- else:- return "low"-- def _evaluate_strategic_importance(self, region: str) -> str:- """Evaluate strategic importance of a region per Brzezinski framework"""- high_importance_regions = ["europe", "east_asia", "russia_near_abroad", "central_asia"]- return "high" if region in high_importance_regions else "medium"-- def _identify_american_interests(self, region: str) -> List[str]:- """Identify key American interests in specific regions"""- interests_map = {- "europe": ["NATO cohesion", "European integration", "Democratic stability"],- "russia_near_abroad": ["Containment of Russian expansion", "Sovereignty support", "Energy diversification"],- "central_asia": ["Preventing single power dominance", "Resource access", "Counter-terrorism"],- "east_asia": ["Freedom of navigation", "Alliance maintenance", "China rise management"],- "middle_east": ["Energy security", "Counter-terrorism", "Regional stability"],- "south_asia": ["India partnership", "Pakistan stability", "Counter-terrorism"]- }- return interests_map.get(region, ["Regional stability", "American influence"])-- # Additional helper methods would be implemented for all analytical functions- # For brevity, returning placeholder implementations for complex analytical methods--def eurasian_chessboard_master_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function following existing codebase patterns-- Args:- state: AgentState with current geopolitical data-- Returns:- Strategic assessment of Eurasian chessboard- """- agent = EurasianChessboardMasterAgent()- return agent.analyze_eurasian_chessboard(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "current_events": [- {"id": "1", "type": "diplomatic", "region": "east_asia", "description": "China announces new military exercises"},- {"id": "2", "type": "economic", "region": "europe", "description": "EU discusses defense integration"}- ],- "strategic_moves_by_powers": {- "military_moves": {"china": "increased", "russia": "maintained"},- "economic_moves": {"china": "expansion", "us": "competition"}- },- "military_deployments": [- {"location": "pacific", "force": "carrier_strike_group", "country": "us"}- ],- "economic_indicators": {- "us_growth": 2.1, "china_growth": 4.8, "eu_growth": 1.4- }- }-- result = eurasian_chessboard_master_agent(test_state)- print("Eurasian Chessboard Master Analysis Results:")- print(f"Primacy Status: {result.get('primacy_assessment', {}).get('current_status', 'unknown')}")- print(f"Hegemony Risk Level: {result.get('hegemony_analysis', {}).get('overall_hegemony_risk', 'unknown')}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/far_eastern_anchor_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/far_eastern_anchor_agent.pydeleted file mode 100644index 30a7faf72..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/far_eastern_anchor_agent.py+++ /dev/null@@ -1,788 +0,0 @@-"""-FAR EASTERN ANCHOR AGENT-East Asian Balance of Power Analysis for Grand Chessboard Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - east_asia_events (array)-# - china_developments (array)-# - japanese_developments (array)-# - indo_pacific_dynamics (object)-# - FAR_EASTERN_ANCHOR_API_KEY-#-# OUTPUT:-# - East Asian power balance assessment-# - China rise analysis and regional impact-# - Japan's international role evaluation-# - American strategic balancing recommendations-#-# PARAMETERS:-# - analysis_focus="china_rise_management"-# - strategic_timeframe="decade"-# - perspective="american_balance_maintenance"-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator-from ..geostrategic_modules.containment_strategy import ContainmentStrategy--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class ChinaTrajectory(Enum):- """China's strategic trajectory assessment"""- REGIONAL_HEDGEOM = "regional_hegemon" # Achieving regional dominance- GLOBAL_POWER = "global_power" # Aspiring to global status- CONSTRAINED_RISE = "constrained_rise" # Rise limited by external factors- INTERNAL_CHALLENGES = "internal_challenges" # Domestic issues limiting expansion- COOPERATIVE_PARTNER = "cooperative_partner" # Integrating into international order--class BalanceLevel(Enum):- """Level of regional balance of power"""- BALANCED = "balanced" # No clear dominant power- CHINA_DOMINANT = "china_dominant" # China clearly leading- AMERICAN_DOMINANT = "american_dominant" # US clearly leading- BIPOLAR = "bipolar" # US-China bipolar competition- MULTIPOLAR = "multipolar" # Multiple powers balanced--@dataclass-class EastAsiaStrategicAssessment:- """Strategic assessment of East Asian balance of power"""- balance_level: BalanceLevel- china_trajectory: ChinaTrajectory- american_leadership: float # 0-1 scale- regional_stability: str # stable, tense, volatile- alliance_effectiveness: float # 0-1 scale- economic_interdependence: float # 0-1 scale- military_balance: float # 0-1 scale- strategic_recommendations: List[str]--@dataclass-class RegionalPowerStructure:- """Power structure across East Asian subregions"""- china_capabilities: Dict[str, float]- japan_capabilities: Dict[str, float]- us_presence: Dict[str, float]- regional_powers: Dict[str, Dict[str, float]] # South Korea, Taiwan, ASEAN- alliance_structures: Dict[str, List[str]]- security_dilemmas: Dict[str, Any]--class FarEasternAnchorAgent:- """- FAR EASTERN ANCHOR AGENT - East Asian Balance of Power Analysis-- Core Thesis: East Asia as critical region for 21st century balance of power- - China's rise as regional power with global aspirations threatening American primacy- - Japan's role as international power supporting American leadership- - Taiwan Straits and Korean Peninsula as critical flashpoints for regional stability- - Maritime competition in South China Sea and East China Sea- - American forward presence and alliance network as balancing mechanisms-- Brzezinski Framework: Maintaining regional balance to prevent Chinese regional hegemony- """-- def __init__(self):- """Initialize Far Eastern Anchor agent"""- self.agent_id = "far_eastern_anchor_agent"- self.balance_calculator = BalanceOfPowerCalculator()- self.containment_strategist = ContainmentStrategy()-- # East Asian subregions per Brzezinski- self.east_asia_subregions = [- "northeast_asia", "southeast_asia", "oceania",- "south_china_sea", "east_china_sea", "taiwan_straits"- ]-- # Key regional powers- self.regional_powers = [- "china", "japan", "south_korea", "taiwan", "vietnam",- "philippines", "indonesia", "malaysia", "singapore",- "australia", "new_zealand", "india"- ]-- # Great powers with interests in East Asia- self.great_powers = [- "united_states", "china", "japan", "russia",- "india", "australia"- ]-- # Critical maritime domains- self.critical_maritime_domains = [- "south_china_sea", "east_china_sea", "taiwan_straits",- "strait_of_malacca", "sea_of_japan", "yellow_sea"- ]-- # Strategic flashpoints- self.strategic_flashpoints = [- "taiwan_straits", "korean_peninsula", "south_china_sea_disputes",- "senkaku_diaoyu_islands", "paracel_spratly_islands"- ]-- def analyze_far_eastern_anchor(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for Far Eastern Anchor assessment-- Args:- state: AgentState containing East Asian geopolitical data-- Returns:- Comprehensive assessment of East Asian balance of power- """- try:- logger.info("Starting Far Eastern Anchor analysis")-- # Extract relevant data from state- east_asia_events = state.get("east_asia_events", [])- china_developments = state.get("china_developments", [])- japanese_developments = state.get("japanese_developments", [])- indo_pacific_dynamics = state.get("indo_pacific_dynamics", {})-- # Core Brzezinski analysis components- regional_power_structure = self._analyze_regional_power_structure(- east_asia_events, china_developments, japanese_developments- )-- china_rise_analysis = self._analyze_china_rise(- china_developments, east_asia_events, indo_pacific_dynamics- )-- japan_role_analysis = self._analyze_japan_role(- japanese_developments, east_asia_events, regional_power_structure- )-- american_balancing = self._analyze_american_balancing(- east_asia_events, indo_pacific_dynamics, regional_power_structure- )-- maritime_competition = self._analyze_maritime_competition(- east_asia_events, china_developments, japanese_developments- )-- alliance_network = self._analyze_alliance_network(- east_asia_events, indo_pacific_dynamics- )-- # Strategic assessment- strategic_assessment = self._assess_regional_balance(- regional_power_structure, china_rise_analysis, american_balancing- )-- # Stability and security assessment- security_assessment = self._assess_regional_security(- strategic_assessment, maritime_competition, alliance_network- )-- # Strategic opportunities and threats- american_opportunities = self._identify_american_opportunities(- strategic_assessment, alliance_network, regional_power_structure- )-- chinese_challenges = self._identify_chinese_challenges(- china_rise_analysis, regional_power_structure, maritime_competition- )-- # Strategic recommendations- strategic_recommendations = self._generate_far_eastern_recommendations(- strategic_assessment, security_assessment, american_opportunities,- chinese_challenges- )-- # Compile comprehensive assessment- far_eastern_assessment = {- "assessment_type": "far_eastern_anchor",- "timestamp": state.get("timestamp", ""),- "regional_power_structure": regional_power_structure,- "china_rise_analysis": china_rise_analysis,- "japan_role_analysis": japan_role_analysis,- "american_balancing": american_balancing,- "maritime_competition": maritime_competition,- "alliance_network": alliance_network,- "strategic_assessment": strategic_assessment,- "security_assessment": security_assessment,- "american_opportunities": american_opportunities,- "chinese_challenges": chinese_challenges,- "strategic_recommendations": strategic_recommendations,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- far_eastern_assessment,- "Far Eastern Anchor strategic analysis completed"- )-- logger.info("Far Eastern Anchor analysis completed successfully")- return far_eastern_assessment-- except Exception as e:- logger.error(f"Error in Far Eastern Anchor analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _analyze_regional_power_structure(- self,- east_asia_events: List[Dict[str, Any]],- china_developments: List[Dict[str, Any]],- japanese_developments: List[Dict[str, Any]]- ) -> RegionalPowerStructure:- """Analyze power structure across East Asian region"""-- # Chinese capabilities assessment- china_capabilities = self._assess_china_capabilities(china_developments, east_asia_events)-- # Japanese capabilities assessment- japan_capabilities = self._assess_japan_capabilities(japanese_developments, east_asia_events)-- # American presence assessment- us_presence = self._assess_us_presence(east_asia_events, chinese_capabilities)-- # Regional powers capabilities- regional_powers = self._assess_regional_powers(east_asia_events)-- # Alliance structures- alliance_structures = self._analyze_alliance_structures(east_asia_events)-- # Security dilemmas- security_dilemmas = self._analyze_security_dilemmas(- east_asia_events, china_capabilities, regional_powers- )-- return RegionalPowerStructure(- china_capabilities=china_capabilities,- japan_capabilities=japan_capabilities,- us_presence=us_presence,- regional_powers=regional_powers,- alliance_structures=alliance_structures,- security_dilemmas=security_dilemmas- )-- def _analyze_china_rise(- self,- china_developments: List[Dict[str, Any]],- east_asia_events: List[Dict[str, Any]],- indo_pacific_dynamics: Dict[str, Any]- ) -> Dict[str, Any]:- """Analyze China's rise and its strategic implications"""-- # China's trajectory assessment- trajectory_indicators = self._assess_china_trajectory_indicators(china_developments)-- # Regional influence expansion- regional_influence = self._assess_china_regional_influence(- china_developments, east_asia_events- )-- # Global aspirations assessment- global_aspirations = self._assess_china_global_aspirations(- china_developments, indo_pacific_dynamics- )-- # Economic and military modernization- modernization_progress = self._assess_china_modernization(china_developments)-- # Belt and Road Initiative analysis- bri_impact = self._assess_bri_impact(china_developments, east_asia_events)-- # Maritime expansion analysis- maritime_expansion = self._assess_china_maritime_expansion(- china_developments, east_asia_events- )-- # Constraints and challenges- rise_constraints = self._identify_china_rise_constraints(- china_developments, east_asia_events, regional_influence- )-- return {- "trajectory_indicators": trajectory_indicators,- "regional_influence": regional_influence,- "global_aspirations": global_aspirations,- "modernization_progress": modernization_progress,- "bri_impact": bri_impact,- "maritime_expansion": maritime_expansion,- "rise_constraints": rise_constraints,- "trajectory_assessment": self._determine_china_trajectory(trajectory_indicators),- "hegemony_potential": self._assess_hegemony_potential(- regional_influence, modernization_progress, rise_constraints- )- }-- def _analyze_japan_role(- self,- japanese_developments: List[Dict[str, Any]],- east_asia_events: List[Dict[str, Any]],- power_structure: RegionalPowerStructure- ) -> Dict[str, Any]:- """Analyze Japan's role as international power"""-- # Japan's strategic posture- strategic_posture = self._assess_japan_strategic_posture(japanese_developments)-- # Military capabilities and expansion- military_capabilities = self._assess_japan_military_capabilities(japanese_developments)-- # Economic and technological leadership- economic_technological_role = self._assess_japan_economic_technological_role(- japanese_developments- )-- # Diplomatic and regional leadership- diplomatic_leadership = self._assess_japan_diplomatic_leadership(- japanese_developments, east_asia_events- )-- # US-Japan alliance analysis- us_japan_alliance = self._analyze_us_japan_alliance(- japanese_developments, power_structure- )-- # Regional security role- regional_security_role = self._assess_japan_regional_security_role(- japanese_developments, east_asia_events- )-- return {- "strategic_posture": strategic_posture,- "military_capabilities": military_capabilities,- "economic_technological_role": economic_technological_role,- "diplomatic_leadership": diplomatic_leadership,- "us_japan_alliance": us_japan_alliance,- "regional_security_role": regional_security_role,- "international_contribution": self._assess_japan_international_contribution(),- "strategic_autonomy": self._assess_japan_strategic_autonomy(),- "balancing_role": self._assess_japan_balancing_role(power_structure)- }-- def _analyze_american_balancing(- self,- east_asia_events: List[Dict[str, Any]],- indo_pacific_dynamics: Dict[str, Any],- power_structure: RegionalPowerStructure- ) -> Dict[str, Any]:- """Analyze American balancing strategy in East Asia"""-- # US military presence and capabilities- military_presence = self._assess_us_military_presence(east_asia_events)-- # Alliance network effectiveness- alliance_effectiveness = self._assess_alliance_network_effectiveness(- indo_pacific_dynamics, power_structure- )-- # Economic engagement- economic_engagement = self._assess_us_economic_engagement(east_asia_events)-- # Diplomatic leadership- diplomatic_leadership = self._assess_us_diplomatic_leadership(- east_asia_events, indo_pacific_dynamics- )-- # Containment strategy assessment- containment_strategy = self._assess_china_containment_strategy(- east_asia_events, power_structure- )-- # Balancing mechanisms- balancing_mechanisms = self._assess_balancing_mechanisms(- east_asia_events, power_structure, military_presence- )-- return {- "military_presence": military_presence,- "alliance_effectiveness": alliance_effectiveness,- "economic_engagement": economic_engagement,- "diplomatic_leadership": diplomatic_leadership,- "containment_strategy": containment_strategy,- "balancing_mechanisms": balancing_mechanisms,- "strategic_commitments": self._identify_us_strategic_commitments(),- "force_posture": self._assess_us_force_posture(east_asia_events),- "deterrence_capability": self._assess_us_deterrence_capability()- }-- def _analyze_maritime_competition(- self,- east_asia_events: List[Dict[str, Any]],- china_developments: List[Dict[str, Any]],- japanese_developments: List[Dict[str, Any]]- ) -> Dict[str, Any]:- """Analyze maritime competition in critical seas"""-- # Maritime domain control assessment- domain_control = {}- for domain in self.critical_maritime_domains:- domain_control[domain] = self._assess_maritime_domain_control(- domain, east_asia_events- )-- # Naval capabilities comparison- naval_capabilities = self._compare_regional_naval_capabilities(- east_asia_events, china_developments, japanese_developments- )-- # Maritime disputes analysis- maritime_disputes = self._analyze_maritime_disputes(east_asia_events)-- # Sea lane security- sea_lane_security = self._assess_sea_lane_security(east_asia_events)-- # Island chain strategy- island_chain_dynamics = self._analyze_island_chain_strategy(- east_asia_events, china_developments- )-- return {- "domain_control": domain_control,- "naval_capabilities": naval_capabilities,- "maritime_disputes": maritime_disputes,- "sea_lane_security": sea_lane_security,- "island_chain_dynamics": island_chain_dynamics,- "maritime_deterrence": self._assess_maritime_deterrence(),- "anti_access_strategy": self._analyze_anti_access_strategies(),- "maritime_cooperation": self._assess_maritime_cooperation()- }-- def _assess_regional_balance(- self,- power_structure: RegionalPowerStructure,- china_analysis: Dict[str, Any],- american_analysis: Dict[str, Any]- ) -> EastAsiaStrategicAssessment:- """Assess overall regional balance of power"""-- # Calculate power balance metrics- china_power = self._calculate_composite_power(power_structure.china_capabilities)- japan_power = self._calculate_composite_power(power_structure.japan_capabilities)- us_power = self._calculate_composite_power(power_structure.us_presence)-- # Regional power distribution- total_power = china_power + japan_power + us_power- china_share = china_power / total_power if total_power > 0 else 0- us_share = us_power / total_power if total_power > 0 else 0- japan_share = japan_power / total_power if total_power > 0 else 0-- # Determine balance level- balance_level = self._determine_balance_level(china_share, us_share, japan_share)-- # China trajectory assessment- china_trajectory = china_analysis.get("trajectory_assessment", ChinaTrajectory.CONSTRAINED_RISE)-- # American leadership assessment- american_leadership = us_share / (us_share + china_share) if (us_share + china_share) > 0 else 0.5-- # Regional stability assessment- regional_stability = self._assess_regional_stability_level(- power_structure, china_analysis, american_analysis- )-- # Alliance effectiveness- alliance_effectiveness = american_analysis.get("alliance_effectiveness", 0.5)-- # Economic interdependence- economic_interdependence = self._assess_economic_interdependence(power_structure)-- # Military balance- military_balance = self._assess_military_balance(power_structure)-- # Strategic recommendations- strategic_recommendations = self._generate_balance_recommendations(- balance_level, china_trajectory, american_leadership- )-- return EastAsiaStrategicAssessment(- balance_level=balance_level,- china_trajectory=china_trajectory,- american_leadership=american_leadership,- regional_stability=regional_stability,- alliance_effectiveness=alliance_effectiveness,- economic_interdependence=economic_interdependence,- military_balance=military_balance,- strategic_recommendations=strategic_recommendations- )-- def _generate_far_eastern_recommendations(- self,- strategic_assessment: EastAsiaStrategicAssessment,- security_assessment: Dict[str, Any],- american_opportunities: List[str],- chinese_challenges: List[str]- ) -> List[str]:- """Generate strategic recommendations for Far Eastern Anchor"""-- recommendations = []-- # Balance-specific recommendations- if strategic_assessment.balance_level == BalanceLevel.CHINA_DOMINANT:- recommendations.append(- "Strengthen American and allied deterrence capabilities"- )- recommendations.append(- "Enhance regional alliance cooperation against Chinese coercion"- )- elif strategic_assessment.balance_level == BalanceLevel.BIPOLAR:- recommendations.append(- "Maintain credible deterrence while managing competition"- )- recommendations.append(- "Reduce escalation risks through crisis communication mechanisms"- )-- # China trajectory-specific recommendations- if strategic_assessment.china_trajectory == ChinaTrajectory.REGIONAL_HEGEMONY:- recommendations.append(- "Implement comprehensive containment of Chinese regional expansion"- )- recommendations.append(- "Support regional resistance to Chinese pressure and coercion"- )-- # Alliance strengthening recommendations- if strategic_assessment.alliance_effectiveness < 0.7:- recommendations.append(- "Deepen alliances with Japan, South Korea, Australia"- )- recommendations.append(- "Expand security partnerships with Southeast Asian countries"- )-- # Maritime security recommendations- recommendations.extend([- "Maintain freedom of navigation operations in contested waters",- "Strengthen anti-access/area denial capabilities",- "Enhance maritime domain awareness and cooperation",- "Support regional maritime capacity building"- ])-- # Economic engagement recommendations- recommendations.extend([- "Counter Belt and Road Initiative with alternative development projects",- "Strengthen economic resilience of regional partners",- "Promote trade diversification and supply chain security"- ])-- # Leverage opportunities- if american_opportunities:- recommendations.extend(american_opportunities[:3])-- # Address challenges- if chinese_challenges:- recommendations.extend(chinese_challenges[:3])-- # Long-term strategic recommendations- recommendations.extend([- "Maintain long-term American forward presence in region",- "Develop integrated deterrence strategy across all domains",- "Support regional institutions that balance Chinese influence",- "Coordinate with allies on technology and security cooperation"- ])-- return recommendations-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's Far Eastern Anchor framework"""-- validation_criteria = {- "far_eastern_focus": True, # East Asia as critical strategic region- "china_rise_management": True, # Managing Chinese regional expansion- "american_balancing": True, # American leadership in balance maintenance- "japan_international_role": True, # Japan as international power partner- "maritime_competition": True, # Maritime domain as key competition area- "alliance_network": True, # Alliance network as balancing mechanism- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "East Asia as critical region for 21st century balance of power",- "China's rise requiring American balancing and containment",- "Japan as essential international power supporting American leadership",- "Maritime competition as central to regional stability",- "Alliance network as mechanism for preventing Chinese dominance",- "American forward presence and commitment to regional security"- ]- }-- def _calculate_confidence_score(self, state: AgentState) -> float:- """Calculate confidence score for Far Eastern Anchor assessment"""-- # Data quality assessment- data_completeness = self._assess_data_completeness(state)- data_recency = self._assess_data_recency(state)-- # Analytical clarity- regional_coverage = self._assess_regional_coverage(state)- event_relevance = self._assess_event_relevance(state)-- # Calculate weighted confidence- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- regional_coverage * 0.35 +- event_relevance * 0.25- )-- return min(confidence, 1.0)-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""-- return {- "assessment_type": "far_eastern_anchor",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Maintain credible deterrence against Chinese expansion",- "Strengthen alliance network with Japan, South Korea, Australia",- "Preserve freedom of navigation in contested maritime domains",- "Support regional resistance to Chinese coercion",- "Maintain American forward presence and commitment"- ],- "confidence_score": 0.0- }-- # Helper method implementations- def _assess_china_capabilities(self, developments: List[Dict[str, Any]], events: List[Dict[str, Any]]) -> Dict[str, float]:- """Assess Chinese capabilities on multiple dimensions"""- return {- "military": 0.8,- "economic": 0.9,- "technological": 0.7,- "diplomatic": 0.6,- "maritime": 0.7,- "space": 0.6,- "cyber": 0.7- }-- def _assess_japan_capabilities(self, developments: List[Dict[str, Any]], events: List[Dict[str, Any]]) -> Dict[str, float]:- """Assess Japanese capabilities on multiple dimensions"""- return {- "military": 0.6,- "economic": 0.7,- "technological": 0.8,- "diplomatic": 0.7,- "maritime": 0.8,- "alliance_commitment": 0.9- }-- def _assess_us_presence(self, events: List[Dict[str, Any]], china_capabilities: Dict[str, float]) -> Dict[str, float]:- """Assess American presence in East Asia"""- return {- "military": 0.8,- "naval": 0.9,- "air": 0.8,- "alliance_network": 0.9,- "economic": 0.7,- "technological": 0.9,- "deterrence_capability": 0.8- }-- def _assess_regional_powers(self, events: List[Dict[str, Any]]) -> Dict[str, Dict[str, float]]:- """Assess capabilities of other regional powers"""- return {- "south_korea": {"military": 0.6, "economic": 0.7, "alliance_commitment": 0.8},- "taiwan": {"military": 0.5, "economic": 0.6, "strategic_importance": 0.9},- "australia": {"military": 0.6, "economic": 0.6, "alliance_commitment": 0.8},- "asean": {"collective_capability": 0.4, "strategic_importance": 0.8, "alignment_divided": 0.7}- }-- def _determine_balance_level(self, china_share: float, us_share: float, japan_share: float) -> BalanceLevel:- """Determine overall balance level"""- if china_share > us_share * 1.5:- return BalanceLevel.CHINA_DOMINANT- elif us_share > china_share * 1.5:- return BalanceLevel.AMERICAN_DOMINANT- elif china_share > 0.4 and us_share > 0.4:- return BalanceLevel.BIPOLAR- else:- return BalanceLevel.BALANCED-- # Additional helper methods for complete functionality- def _assess_data_completeness(self, state: AgentState) -> float:- """Assess completeness of input data"""- required_fields = ["east_asia_events", "china_developments", "japanese_developments"]- present_fields = sum(1 for field in required_fields if state.get(field))- return present_fields / len(required_fields)-- def _assess_data_recency(self, state: AgentState) -> float:- """Assess recency of input data"""- return 0.8 # Assume reasonably current data-- def _assess_regional_coverage(self, state: AgentState) -> float:- """Assess regional coverage of events"""- events = state.get("east_asia_events", [])- subregions_mentioned = set(event.get("subregion") for event in events if event.get("subregion"))- return len(subregions_mentioned) / len(self.east_asia_subregions)-- def _assess_event_relevance(self, state: AgentState) -> float:- """Assess relevance of events to Far Eastern Anchor analysis"""- events = state.get("east_asia_events", [])- relevant_events = sum(1 for event in events- if event.get("strategic_importance", 0) > 0.5)- return relevant_events / len(events) if events else 0-- def _calculate_composite_power(self, capabilities: Dict[str, float]) -> float:- """Calculate composite power score from capabilities"""- weights = {"military": 0.3, "economic": 0.25, "technological": 0.2,- "diplomatic": 0.15, "maritime": 0.1}- return sum(capabilities.get(key, 0) * weight for key, weight in weights.items())--# Main agent function following existing patterns-def far_eastern_anchor_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function for Far Eastern Anchor analysis-- Args:- state: AgentState with East Asian geopolitical data-- Returns:- Strategic assessment of Far Eastern Anchor dynamics- """- agent = FarEasternAnchorAgent()- return agent.analyze_far_eastern_anchor(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "east_asia_events": [- {"id": "1", "type": "military", "description": "Chinese naval exercises in South China Sea", "strategic_importance": 0.9},- {"id": "2", "type": "diplomatic", "description": "Quad summit security cooperation", "strategic_importance": 0.8},- {"id": "3", "type": "maritime", "description": "Freedom of navigation operation", "strategic_importance": 0.8}- ],- "china_developments": [- {"id": "1", "type": "military", "description": "New aircraft carrier deployment", "capability_type": "power_projection"},- {"id": "2", "type": "economic", "description": "BRI expansion in Southeast Asia", "influence_type": "economic"},- {"id": "3", "type": "technological", "description": "Advanced weapons development", "capability_type": "military_modernization"}- ],- "japanese_developments": [- {"id": "1", "type": "military", "description": "Defense budget increase", "capability_type": "deterrence"},- {"id": "2", "type": "diplomatic", "description": "Enhanced security cooperation", "alliance_type": "strengthening"}- ],- "indo_pacific_dynamics": {- "quad_cooperation": "strengthening",- "asean_alignment": "divided",- "regional_tensions": "increasing"- }- }-- result = far_eastern_anchor_agent(test_state)- print("Far Eastern Anchor Analysis Results:")- print(f"Balance Level: {result.get('strategic_assessment', {}).get('balance_level', 'unknown')}")- print(f"China Trajectory: {result.get('strategic_assessment', {}).get('china_trajectory', 'unknown')}")- print(f"American Leadership: {result.get('strategic_assessment', {}).get('american_leadership', 0):.2f}")- print(f"Alliance Effectiveness: {result.get('strategic_assessment', {}).get('alliance_effectiveness', 0):.2f}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/geostrategic_players_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/geostrategic_players_agent.pydeleted file mode 100644index 6b6ee76a1..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/chessboard_agents/geostrategic_players_agent.py+++ /dev/null@@ -1,824 +0,0 @@-"""-GEOSTRATEGIC PLAYERS AGENT-Great Powers Dynamics Analysis for Grand Chessboard Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - great_power_events (array)-# - player_developments (array)-# - great_power_relations (object)-# - global_balance_data (object)-# - GEOSTRATEGIC_PLAYERS_API_KEY-#-# OUTPUT:-# - Great powers capabilities assessment-# - Power transition dynamics analysis-# - Strategic alignment evaluation-# - Great power competition assessment-#-# PARAMETERS:-# - analysis_focus="power_transition_dynamics"-# - strategic_timeframe="decade"-# - perspective="balance_of_power_analysis"-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum--# Follow existing codebase patterns-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data, get_strategic_analysis--# Import geostrategic modules-from ..geostrategic_modules.balance_of_power import BalanceOfPowerCalculator--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class PowerStatus(Enum):- """Status of great powers in global system"""- RISING = "rising" # Gaining power and influence- STABLE = "stable" # Maintaining current position- DECLINING = "declining" # Losing power and influence- TRANSITIONING = "transitioning" # Undergoing major power transition- CHALLENGED = "challenged" # Facing significant internal/external challenges--class PlayerCategory(Enum):- """Categories of geopolitical players per Brzezinski"""- ESTABLISHED = "established" # Established great powers- EMERGING = "emerging" # Emerging powers with great power potential- REGIONAL = "regional" # Significant regional powers- DECLINING = "declining" # Powers in relative decline- CHALLENGER = "challenger" # Powers challenging the status quo--@dataclass-class PlayerCapabilities:- """Capabilities assessment for a geopolitical player"""- military_power: float # 0-1 scale- economic_strength: float # 0-1 scale- technological_advantage: float # 0-1 scale- diplomatic_influence: float # 0-1 scale- global_reach: float # 0-1 scale- strategic_focus: List[str] # Key strategic priorities- constraints: List[str] # Major limitations/constraints--@dataclass-class PowerTransition:- """Power transition dynamics between players"""- rising_powers: List[str]- declining_powers: List[str]- stable_powers: List[str]- transition_hotspots: List[str]- competition_intensity: float # 0-1 scale- system_stability: str # stable, transitioning, volatile--@dataclass-class GreatPowerAssessment:- """Comprehensive assessment of great powers dynamics"""- player_capabilities: Dict[str, PlayerCapabilities]- power_distribution: Dict[str, float]- transition_dynamics: PowerTransition- strategic_alignments: Dict[str, List[str]]- competition_areas: List[str]- system_stability: str- strategic_recommendations: List[str]--class GeostrategicPlayersAgent:- """- GEOSTRATEGIC PLAYERS AGENT - Great Powers Dynamics Analysis-- Core Thesis: Analysis of major powers that can affect global power distribution- - Established great powers: France, Germany, Russia, China, potentially India- - Emerging powers with global aspirations: Brazil, Turkey, Iran- - Power transition dynamics and balance of power shifts- - Strategic alignment patterns and alliance formations- - Competition areas and potential conflict zones-- Brzezinski Framework: Understanding great power capabilities and managing balance- """-- def __init__(self):- """Initialize Geostrategic Players agent"""- self.agent_id = "geostrategic_players_agent"- self.balance_calculator = BalanceOfPowerCalculator()-- # Great powers per Brzezinski- self.geostrategic_players = [- "united_states", # Global hegemon- "china", # Rising global challenger- "russia", # Resurgent regional power- "germany", # European economic power- "france", # European diplomatic/military power- "japan", # Asian economic/technological power- "india", # Emerging South Asian power- "brazil", # Emerging Latin American power- "turkey", # Regional power with ambitions- "iran" # Regional power with nuclear aspirations- ]-- # Power categories- self.established_powers = ["united_states", "china", "russia", "japan", "germany", "france"]- self.emerging_powers = ["india", "brazil", "turkey", "iran"]- self.regional_powers = ["south_korea", "australia", "canada", "mexico", "south_africa"]-- # Competition areas- self.competition_areas = [- "technological_supremacy", "economic_dominance", "military_advantage",- "diplomatic_leadership", "resource_control", "space_exploration",- "cyber_domain", "ai_development", "energy_security"- ]-- # Strategic alignments per Brzezinski- self.strategic_alignments = {- "western_alliance": ["united_states", "germany", "france", "uk", "japan", "australia"],- "eastern_partnership": ["china", "russia", "iran", "north_korea"],- "non_aligned": ["india", "brazil", "turkey", "south_africa", "many_developing_countries"]- }-- def analyze_geostrategic_players(self, state: AgentState) -> Dict[str, Any]:- """- Main analysis function for great powers dynamics-- Args:- state: AgentState containing great powers data-- Returns:- Comprehensive assessment of geopolitical players dynamics- """- try:- logger.info("Starting Geostrategic Players analysis")-- # Extract relevant data from state- great_power_events = state.get("great_power_events", [])- player_developments = state.get("player_developments", [])- power_relations = state.get("great_power_relations", {})- global_balance = state.get("global_balance_data", {})-- # Core Brzezinski analysis components- player_capabilities = self._assess_player_capabilities(- player_developments, great_power_events- )-- power_distribution = self._analyze_power_distribution(- player_capabilities, global_balance- )-- transition_dynamics = self._analyze_power_transitions(- player_capabilities, power_relations, great_power_events- )-- strategic_alignments = self._analyze_strategic_alignments(- power_relations, great_power_events- )-- competition_analysis = self._analyze_competition_areas(- player_capabilities, great_power_events, power_relations- )-- # Strategic assessment- strategic_assessment = self._assess_overall_dynamics(- player_capabilities, transition_dynamics, strategic_alignments- )-- # Future projections- future_scenarios = self._project_future_power_dynamics(- transition_dynamics, player_capabilities- )-- # Strategic recommendations- strategic_recommendations = self._generate_players_recommendations(- strategic_assessment, transition_dynamics, future_scenarios- )-- # Compile comprehensive assessment- players_assessment = {- "assessment_type": "geostrategic_players",- "timestamp": state.get("timestamp", ""),- "player_capabilities": player_capabilities,- "power_distribution": power_distribution,- "transition_dynamics": transition_dynamics,- "strategic_alignments": strategic_alignments,- "competition_analysis": competition_analysis,- "strategic_assessment": strategic_assessment,- "future_scenarios": future_scenarios,- "strategic_recommendations": strategic_recommendations,- "brzezinski_compliance": self._validate_brzezinski_framework(),- "confidence_score": self._calculate_confidence_score(state)- }-- # Show reasoning for transparency- show_agent_reasoning(- self.agent_id,- players_assessment,- "Geostrategic Players analysis completed"- )-- logger.info("Geostrategic Players analysis completed successfully")- return players_assessment-- except Exception as e:- logger.error(f"Error in Geostrategic Players analysis: {str(e)}")- return self._generate_error_assessment(e)-- def _assess_player_capabilities(- self,- player_developments: List[Dict[str, Any]],- events: List[Dict[str, Any]]- ) -> Dict[str, PlayerCapabilities]:- """Assess capabilities of all great power players"""-- capabilities = {}-- for player in self.geostrategic_players:- # Get player-specific data- player_events = [e for e in events if e.get("primary_player") == player]- player_development = next(- (d for d in player_developments if d.get("player") == player),- {}- )-- # Assess each capability dimension- military_power = self._assess_military_capability(player, player_events, player_development)- economic_strength = self._assess_economic_capability(player, player_events, player_development)- tech_advantage = self._assess_technological_capability(player, player_events, player_development)- diplomatic_influence = self._assess_diplomatic_capability(player, player_events, player_development)- global_reach = self._assess_global_reach(player, player_events, player_development)-- # Determine strategic focus and constraints- strategic_focus = self._identify_strategic_focus(player, player_events, player_development)- constraints = self._identify_player_constraints(player, player_events, player_development)-- capabilities[player] = PlayerCapabilities(- military_power=military_power,- economic_strength=economic_strength,- technological_advantage=tech_advantage,- diplomatic_influence=diplomatic_influence,- global_reach=global_reach,- strategic_focus=strategic_focus,- constraints=constraints- )-- return capabilities-- def _analyze_power_distribution(- self,- capabilities: Dict[str, PlayerCapabilities],- global_balance: Dict[str, Any]- ) -> Dict[str, float]:- """Analyze current power distribution among great powers"""-- distribution = {}-- # Calculate composite power scores- for player, caps in capabilities.items():- composite_score = self._calculate_composite_power_score(caps)- distribution[player] = composite_score-- # Normalize to percentages- total_power = sum(distribution.values())- if total_power > 0:- for player in distribution:- distribution[player] = distribution[player] / total_power-- # Adjust for global balance data if available- if global_balance:- distribution = self._incorporate_global_balance_data(distribution, global_balance)-- return distribution-- def _analyze_power_transitions(- self,- capabilities: Dict[str, PlayerCapabilities],- relations: Dict[str, Any],- events: List[Dict[str, Any]]- ) -> PowerTransition:- """Analyze power transition dynamics among great powers"""-- # Identify rising and declining powers- power_trends = self._identify_power_trends(capabilities, events)- rising_powers = [player for player, trend in power_trends.items() if trend == PowerStatus.RISING]- declining_powers = [player for player, trend in power_trends.items() if trend == PowerStatus.DECLINING]- stable_powers = [player for player, trend in power_trends.items() if trend == PowerStatus.STABLE]-- # Identify transition hotspots- transition_hotspots = self._identify_transition_hotspots(events, relations)-- # Assess competition intensity- competition_intensity = self._calculate_competition_intensity(capabilities, relations)-- # Determine system stability- system_stability = self._assess_system_stability(- rising_powers, declining_powers, competition_intensity- )-- return PowerTransition(- rising_powers=rising_powers,- declining_powers=declining_powers,- stable_powers=stable_powers,- transition_hotspots=transition_hotspots,- competition_intensity=competition_intensity,- system_stability=system_stability- )-- def _analyze_strategic_alignments(- self,- relations: Dict[str, Any],- events: List[Dict[str, Any]]- ) -> Dict[str, List[str]]:- """Analyze current strategic alignments among great powers"""-- alignments = {}-- for player in self.geostrategic_players:- # Determine player's alignments based on relations and events- player_alignments = self._determine_player_alignments(player, relations, events)- alignments[player] = player_alignments-- return alignments-- def _analyze_competition_areas(- self,- capabilities: Dict[str, PlayerCapabilities],- events: List[Dict[str, Any]],- relations: Dict[str, Any]- ) -> List[str]:- """Analyze competition areas among great powers"""-- competition_areas = []-- # Analyze each competition area- for area in self.competition_areas:- area_competition = self._assess_area_competition(area, capabilities, events)- if area_competition["intensity"] > 0.6: # High competition threshold- competition_areas.append(area)-- return competition_areas-- def _assess_overall_dynamics(- self,- capabilities: Dict[str, PlayerCapabilities],- transitions: PowerTransition,- alignments: Dict[str, List[str]]- ) -> Dict[str, Any]:- """Assess overall dynamics of great powers system"""-- # System characteristics- power_concentration = self._calculate_power_concentration(capabilities)- alignment_polarization = self._assess_alignment_polarization(alignments)- transition_velocity = self._assess_transition_velocity(transitions)-- # Strategic stability indicators- stability_indicators = {- "power_balance_stability": transitions.system_stability,- "alignment_coherence": 1 - alignment_polarization,- "transition_smoothness": 1 - transition_velocity,- "competition_intensity": transitions.competition_intensity- }-- # Overall system assessment- overall_stability = self._determine_overall_stability(stability_indicators)-- return {- "power_concentration": power_concentration,- "alignment_polarization": alignment_polarization,- "transition_velocity": transition_velocity,- "stability_indicators": stability_indicators,- "overall_stability": overall_stability,- "system_characteristics": self._describe_system_characteristics(- power_concentration, alignment_polarization, transition_velocity- )- }-- def _project_future_power_dynamics(- self,- transitions: PowerTransition,- capabilities: Dict[str, PlayerCapabilities]- ) -> List[Dict[str, Any]]:- """Project future power dynamics scenarios"""-- scenarios = []-- # Scenario 1: Current trends continue- current_trends_scenario = {- "scenario_name": "Current Trends Continue",- "probability": 0.4,- "description": "Existing power dynamics continue with gradual adjustments",- "key_developments": self._project_current_trends(transitions, capabilities)- }-- # Scenario 2: Major power realignment- realignment_scenario = {- "scenario_name": "Strategic Realignment",- "probability": 0.3,- "description": "Significant changes in great power alignments and partnerships",- "key_developments": self._project_realignment_scenarios(transitions, capabilities)- }-- # Scenario 3: Multipolar competition intensifies- multipolar_scenario = {- "scenario_name": "Intensified Multipolar Competition",- "probability": 0.3,- "description": "Increased competition among multiple great powers",- "key_developments": self._project_multipolar_scenarios(transitions, capabilities)- }-- scenarios = [current_trends_scenario, realignment_scenario, multipolar_scenario]-- return scenarios-- def _generate_players_recommendations(- self,- strategic_assessment: Dict[str, Any],- transitions: PowerTransition,- future_scenarios: List[Dict[str, Any]]- ) -> List[str]:- """Generate strategic recommendations for managing great powers dynamics"""-- recommendations = []-- # System stability recommendations- if strategic_assessment.get("overall_stability") == "unstable":- recommendations.extend([- "Strengthen diplomatic mechanisms for crisis management",- "Enhance strategic communication channels",- "Support international institutions for conflict prevention",- "Promote power balance through diplomatic engagement"- ])-- # Power transition recommendations- if transitions.rising_powers:- recommendations.extend([- "Engage constructively with rising powers",- "Manage power transitions through diplomatic means",- "Prevent destabilizing actions during power shifts",- "Support peaceful transition to new power configurations"- ])-- # Competition management recommendations- high_competition_areas = strategic_assessment.get("competition_areas", [])- if high_competition_areas:- recommendations.extend([- f"Manage competition in {', '.join(high_competition_areas)}",- "Establish rules of engagement for competitive domains",- "Develop crisis prevention mechanisms",- "Promote cooperation in areas of mutual interest"- ])-- # Alignment management recommendations- polarization = strategic_assessment.get("alignment_polarization", 0)- if polarization > 0.7: # High polarization threshold- recommendations.extend([- "Reduce polarization through bridge-building diplomacy",- "Support multipolar frameworks",- "Encourage cross-alignment cooperation",- "Maintain strategic autonomy in alliance decisions"- ])-- # Long-term strategic recommendations- recommendations.extend([- "Support international order that accommodates multiple powers",- "Promote global governance reforms for emerging powers",- "Develop cooperative approaches to global challenges",- "Maintain credible deterrence while pursuing diplomatic solutions"- ])-- return recommendations-- def _validate_brzezinski_framework(self) -> Dict[str, Any]:- """Validate compliance with Brzezinski's great powers framework"""-- validation_criteria = {- "great_power_recognition": True, # Recognition of established and emerging powers- "power_transition_focus": True, # Emphasis on power transition dynamics- "balance_of_power_analysis": True, # Analysis of power balance and competition- "strategic_alignment_understanding": True, # Understanding of alliance patterns- "global_dynamics_perspective": True, # Global rather than regional perspective- }-- compliance_score = sum(validation_criteria.values()) / len(validation_criteria)-- return {- "framework_compliance": compliance_score,- "validation_criteria": validation_criteria,- "brzezinski_principles_applied": [- "Recognition of established and emerging great powers",- "Analysis of power transition dynamics and balance changes",- "Understanding of strategic alignments and alliance patterns",- "Assessment of global power distribution and competition",- "Management of great power relations through balance and diplomacy"- ]- }-- def _calculate_confidence_score(self, state: AgentState) -> float:- """Calculate confidence score for players assessment"""-- # Data quality assessment- data_completeness = self._assess_data_completeness(state)- data_recency = self._assess_data_recency(state)-- # Analytical clarity- player_coverage = self._assess_player_coverage(state)- data_reliability = self._assess_data_reliability(state)-- # Calculate weighted confidence- confidence = (- data_completeness * 0.25 +- data_recency * 0.15 +- player_coverage * 0.35 +- data_reliability * 0.25- )-- return min(confidence, 1.0)-- # Helper method implementations- def _assess_military_capability(self, player: str, events: List[Dict], development: Dict) -> float:- """Assess military capability of a specific player"""- # Base military capability scores by player- base_capabilities = {- "united_states": 0.9,- "china": 0.8,- "russia": 0.7,- "japan": 0.6,- "germany": 0.5,- "france": 0.5,- "india": 0.4,- "brazil": 0.3,- "turkey": 0.4,- "iran": 0.3- }-- base_score = base_capabilities.get(player, 0.3)-- # Adjust based on recent developments- military_events = [e for e in events if e.get("type") == "military" and e.get("primary_player") == player]- for event in military_events:- if event.get("impact", 0) > 0:- base_score = min(1.0, base_score + 0.1)- elif event.get("impact", 0) < 0:- base_score = max(0.0, base_score - 0.1)-- return min(base_score + development.get("military_trend", 0), 1.0)-- def _assess_economic_capability(self, player: str, events: List[Dict], development: Dict) -> float:- """Assess economic capability of a specific player"""- base_capabilities = {- "united_states": 0.85,- "china": 0.8,- "japan": 0.75,- "germany": 0.7,- "france": 0.6,- "india": 0.5,- "russia": 0.4,- "brazil": 0.3,- "turkey": 0.4,- "iran": 0.3- }-- base_score = base_capabilities.get(player, 0.3)- return min(base_score + development.get("economic_trend", 0), 1.0)-- def _assess_technological_capability(self, player: str, events: List[Dict], development: Dict) -> float:- """Assess technological capability of a specific player"""- base_capabilities = {- "united_states": 0.9,- "china": 0.7,- "japan": 0.8,- "germany": 0.7,- "france": 0.6,- "india": 0.5,- "russia": 0.5,- "brazil": 0.3,- "turkey": 0.4,- "iran": 0.4- }-- base_score = base_capabilities.get(player, 0.3)- return min(base_score + development.get("technology_trend", 0), 1.0)-- def _assess_diplomatic_capability(self, player: str, events: List[Dict], development: Dict) -> float:- """Assess diplomatic capability of a specific player"""- base_capabilities = {- "united_states": 0.8,- "china": 0.6,- "russia": 0.7,- "france": 0.7,- "germany": 0.6,- "japan": 0.6,- "india": 0.5,- "brazil": 0.4,- "turkey": 0.5,- "iran": 0.4- }-- base_score = base_capabilities.get(player, 0.3)- return min(base_score + development.get("diplomatic_trend", 0), 1.0)-- def _assess_global_reach(self, player: str, events: List[Dict], development: Dict) -> float:- """Assess global reach and influence of a specific player"""- base_capabilities = {- "united_states": 0.9,- "china": 0.7,- "russia": 0.6,- "france": 0.5,- "united_kingdom": 0.5,- "japan": 0.5,- "germany": 0.4,- "india": 0.4,- "brazil": 0.3,- "turkey": 0.4,- "iran": 0.3- }-- base_score = base_capabilities.get(player, 0.3)- return min(base_score + development.get("global_reach_trend", 0), 1.0)-- def _identify_strategic_focus(self, player: str, events: List[Dict], development: Dict) -> List[str]:- """Identify strategic focus areas for a specific player"""- # Strategic focus patterns by player- player_focuses = {- "united_states": ["global_leadership", "alliance_management", "containment", "freedom_of_navigation"],- "china": ["regional_dominance", "belt_road_initiative", "technological_supremacy", "resource_security"],- "russia": ["near_abroad_influence", "military_modernization", "energy_politics", "great_power_status"],- "japan": ["technological_leadership", "regional_security", "us_alliance_partnership", "economic_recovery"],- "germany": ["european_integration", "economic_leadership", "multilateralism", "green_transition"],- "france": ["european_independence", "military_capability", "global_diplomacy", "nuclear_deterrence"],- "india": ["regional_dominance", "economic_development", "strategic_autonomy", "border_security"],- "brazil": ["regional_leadership", "economic_growth", "south_american_integration", "global_role"],- "turkey": ["regional_leadership", "nato_partnership", "islamic_world_leadership", "energy_hub"],- "iran": ["regional_influence", "nuclear_deterrence", "anti_western_alignment", "shia_crescent"]- }-- return player_focuses.get(player, ["power_maintenance"])-- def _identify_player_constraints(self, player: str, events: List[Dict], development: Dict) -> List[str]:- """Identify major constraints facing a specific player"""- # Common constraints by player- player_constraints = {- "united_states": ["global_overextension", "domestic_political_division", "economic_challenges", "alliance_management"],- "china": ["demographic_challenges", "energy_dependencies", "technological_gaps", "containment_pressure"],- "russia": ["economic_limitations", "demographic_decline", "technological_lag", "sanctions_pressure"],- "japan": ["demographic_decline", "economic_stagnation", "constitutional_constraints", "regional_tensions"],- "germany": ["military_constraints", "european_coordination", "energy_dependencies", "historical_constraints"],- "france": ["economic_constraints", "global_leadership_limitations", "european_coordination", "colonial_legacy"],- "india": ["poverty", "infrastructure_deficits", "regional_conflicts", "bureaucratic_challenges"],- "brazil": ["economic_instability", "crime", "inequality", "infrastructure_limitations"],- "turkey": ["economic_instability", "regional_tensions", "demographic_challenges", "secular_religious_divisions"],- "iran": ["sanctions", "economic_isolation", "technological_obsolescence", "regional_opposition"]- }-- return player_constraints.get(player, ["resource_constraints"])-- # Additional helper methods for complete functionality- def _calculate_composite_power_score(self, caps: PlayerCapabilities) -> float:- """Calculate composite power score from individual capabilities"""- weights = {- "military_power": 0.25,- "economic_strength": 0.25,- "technological_advantage": 0.2,- "diplomatic_influence": 0.15,- "global_reach": 0.15- }-- return (- caps.military_power * weights["military_power"] +- caps.economic_strength * weights["economic_strength"] +- caps.technological_advantage * weights["technological_advantage"] +- caps.diplomatic_influence * weights["diplomatic_influence"] +- caps.global_reach * weights["global_reach"]- )-- def _identify_power_trends(self, capabilities: Dict[str, PlayerCapabilities], events: List[Dict]) -> Dict[str, PowerStatus]:- """Identify current power trends for each player"""- trends = {}-- for player, caps in capabilities.items():- # Analyze trend indicators from events- trend_events = [e for e in events if e.get("primary_player") == player and e.get("trend_indicator")]-- if trend_events:- positive_trends = sum(1 for e in trend_events if e.get("trend_indicator") > 0)- negative_trends = sum(1 for e in trend_events if e.get("trend_indicator") < 0)-- if positive_trends > negative_trends:- trends[player] = PowerStatus.RISING- elif negative_trends > positive_trends:- trends[player] = PowerStatus.DECLINING- else:- trends[player] = PowerStatus.STABLE- else:- # Default assessment based on capabilities profile- if caps.military_power > 0.7 and caps.economic_strength > 0.7:- trends[player] = PowerStatus.RISING- elif caps.military_power < 0.4 or caps.economic_strength < 0.4:- trends[player] = PowerStatus.DECLINING- else:- trends[player] = PowerStatus.STABLE-- return trends-- def _calculate_competition_intensity(self, capabilities: Dict[str, PlayerCapabilities], relations: Dict) -> float:- """Calculate overall competition intensity among powers"""- # Count players with high capabilities in key areas- military_leaders = [p for p, caps in capabilities.items() if caps.military_power > 0.7]- economic_leaders = [p for p, caps in capabilities.items() if caps.economic_strength > 0.7]- tech_leaders = [p for p, caps in capabilities.items() if caps.technological_advantage > 0.7]-- # Competition intensity based on number of strong players- leader_count = len(set(military_leaders + economic_leaders + tech_leaders))- return min(leader_count / len(self.geostrategic_players), 1.0)-- # Additional helper methods for complete functionality- def _assess_data_completeness(self, state: AgentState) -> float:- """Assess completeness of input data"""- required_fields = ["great_power_events", "player_developments", "great_power_relations"]- present_fields = sum(1 for field in required_fields if state.get(field))- return present_fields / len(required_fields)-- def _assess_data_recency(self, state: AgentState) -> float:- """Assess recency of input data"""- return 0.8 # Assume reasonably current data-- def _assess_player_coverage(self, state: AgentState) -> float:- """Assess coverage of all great powers"""- events = state.get("great_power_events", [])- players_mentioned = set(e.get("primary_player") for e in events if e.get("primary_player"))- return len(players_mentioned) / len(self.geostrategic_players)-- def _assess_data_reliability(self, state: AgentState) -> float:- """Assess reliability of input data sources"""- return 0.8 # Assume reasonably reliable data-- def _generate_error_assessment(self, error: Exception) -> Dict[str, Any]:- """Generate error assessment when analysis fails"""- return {- "assessment_type": "geostrategic_players",- "error_occurred": True,- "error_message": str(error),- "assessment_status": "failed",- "fallback_recommendations": [- "Maintain diplomatic engagement with all great powers",- "Support balance of power principles",- "Strengthen international institutions",- "Monitor power transitions and emerging challenges",- "Promote cooperative approaches to global issues"- ],- "confidence_score": 0.0- }--# Main agent function following existing patterns-def geostrategic_players_agent(state: AgentState) -> Dict[str, Any]:- """- Main agent function for Geostrategic Players analysis-- Args:- state: AgentState with great powers geopolitical data-- Returns:- Strategic assessment of great powers dynamics- """- agent = GeostrategicPlayersAgent()- return agent.analyze_geostrategic_players(state)--# Entry point for testing-if __name__ == "__main__":- # Test data for development- test_state = {- "great_power_events": [- {"id": "1", "type": "military", "primary_player": "china", "trend_indicator": 1, "description": "China announces naval expansion"},- {"id": "2", "type": "diplomatic", "primary_player": "russia", "trend_indicator": -1, "description": "Russia faces international isolation"},- {"id": "3", "type": "economic", "primary_player": "india", "trend_indicator": 1, "description": "India shows strong economic growth"},- {"id": "4", "type": "technological", "primary_player": "united_states", "trend_indicator": 1, "description": "US advances AI capabilities"}- ],- "player_developments": [- {"player": "china", "military_trend": 0.1, "economic_trend": 0.1, "technology_trend": 0.1},- {"player": "russia", "military_trend": -0.05, "economic_trend": -0.1, "technology_trend": 0.0},- {"player": "united_states", "military_trend": 0.05, "economic_trend": -0.05, "technology_trend": 0.1},- {"player": "india", "military_trend": 0.05, "economic_trend": 0.1, "technology_trend": 0.05}- ],- "great_power_relations": {- "alignments": {- "western_alliance": ["united_states", "germany", "france", "japan", "uk", "australia"],- "eastern_partnership": ["china", "russia", "north_korea", "iran"],- "non_aligned": ["india", "brazil", "turkey", "south_africa"]- },- "competition_areas": {- "technological_supremacy": {"leaders": ["united_states", "china"], "intensity": 0.8},- "economic_dominance": {"leaders": ["united_states", "china"], "intensity": 0.7}- }- },- "global_balance_data": {- "power_transition": "ongoing",- "system_stability": "moderately_stable",- "competition_intensity": 0.6- }- }-- result = geostrategic_players_agent(test_state)- print("Geostrategic Players Analysis Results:")- print(f"System Stability: {result.get('strategic_assessment', {}).get('overall_stability', 'unknown')}")- print(f"Rising Powers: {result.get('transition_dynamics', {}).get('rising_powers', [])}")- print(f"Competition Intensity: {result.get('strategic_assessment', {}).get('competition_intensity', 0):.2f}")- print(f"Confidence Score: {result.get('confidence_score', 0):.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/agent_coordination.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/agent_coordination.pydeleted file mode 100644index 7ff56d805..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/agent_coordination.py+++ /dev/null@@ -1,896 +0,0 @@-"""-AGENT COORDINATION SYSTEM-Inter-Agent Communication and Data Sharing for Grand Chessboard Framework--This module implements a sophisticated coordination system that allows-Grand Chessboard agents to communicate, share data, and collaborate on-comprehensive strategic analysis through shared chessboard state management.-"""--import logging-from typing import Dict, List, Any, Optional, Tuple, Callable-from dataclasses import dataclass, field-from enum import Enum-from datetime import datetime-import asyncio-import threading-import queue-import json--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class MessageType(Enum):- """Types of inter-agent messages"""- DATA_SHARING = "data_sharing" # Share geopolitical data- INSIGHT_SHARING = "insight_sharing" # Share strategic insights- ANALYSIS_REQUEST = "analysis_request" # Request specific analysis- STATUS_UPDATE = "status_update" # Update analysis status- CONFLICT_ALERT = "conflict_alert" # Alert about conflicting recommendations- COORDINATION_REQUEST = "coordination_request" # Request coordination on analysis- RESPONSE = "response" # Response to previous message--class Priority(Enum):- """Message priority levels"""- CRITICAL = "critical" # Urgent strategic intelligence- HIGH = "high" # Important coordination needs- NORMAL = "normal" # Regular information sharing- LOW = "low" # Background updates--@dataclass-class AgentMessage:- """Inter-agent communication message"""- id: str- sender: str- recipients: List[str]- message_type: MessageType- priority: Priority- timestamp: datetime- data: Dict[str, Any]- metadata: Dict[str, Any] = field(default_factory=dict)- requires_response: bool = False- correlation_id: Optional[str] = None--@dataclass-class SharedChessboardState:- """Shared state of Eurasian chessboard across all agents"""- global_power_distribution: Dict[str, float] = field(default_factory=dict)- regional_dynamics: Dict[str, Dict[str, Any]] = field(default_factory=dict)- strategic_priorities: List[str] = field(default_factory=list)- threat_assessments: Dict[str, str] = field(default_factory=dict)- agent_insights: Dict[str, List[Dict[str, Any]]] = field(default_factory=dict)- coordination_requests: List[Dict[str, Any]] = field(default_factory=list)- last_updated: datetime = field(default_factory=datetime.now)--@dataclass-class CoordinationResult:- """Result of coordinated analysis across multiple agents"""- coordinated_by: str- participating_agents: List[str]- combined_insights: Dict[str, Any]- consensus_recommendations: List[str]- conflicting_recommendations: List[Dict[str, Any]]- coordination_success: bool- timestamp: datetime = field(default_factory=datetime.now)--class AgentCoordinationSystem:- """- Sophisticated agent coordination system enabling inter-agent communication- and collaborative analysis through shared chessboard state management.-- Features:- - Message passing between agents with priority queuing- - Shared chessboard state with conflict resolution- - Coordinated analysis requests and result aggregation- - Conflict detection and resolution mechanisms- - Agent status monitoring and health checks- """-- def __init__(self):- """Initialize the agent coordination system"""- self.system_id = "agent_coordination_system"-- # Active agents registry- self.registered_agents = {}-- # Message queues for each agent- self.message_queues = {}-- # Shared chessboard state- self.shared_state = SharedChessboardState()-- # Coordination history- self.coordination_history = []-- # Message routing- self.message_queue = queue.PriorityQueue()- self.message_handlers = {}-- # Locking for thread safety- self.state_lock = threading.Lock()- self.coordination_lock = threading.Lock()-- # Configuration- self.max_queue_size = 1000- self.message_timeout = 300 # 5 minutes- self.coordination_timeout = 600 # 10 minutes-- # Available Grand Chessboard agents- self.available_agents = [- "eurasian_chessboard_master",- "democratic_bridgehead",- "black_hole",- "eurasian_balkans",- "far_eastern_anchor",- "geostrategic_players",- "geopolitical_pivots",- "american_hegemony"- ]-- def register_agent(self, agent_id: str, message_handler: Callable[[AgentMessage], None]) -> bool:- """- Register an agent with the coordination system-- Args:- agent_id: Unique identifier for the agent- message_handler: Function to handle incoming messages-- Returns:- True if registration successful, False otherwise- """- try:- if agent_id in self.registered_agents:- logger.warning(f"Agent {agent_id} already registered")- return False-- if agent_id not in self.available_agents:- logger.warning(f"Agent {agent_id} not recognized as Grand Chessboard agent")- return False-- # Register the agent- self.registered_agents[agent_id] = {- "id": agent_id,- "handler": message_handler,- "status": "active",- "last_seen": datetime.now(),- "message_count": 0,- "coordination_participations": 0- }-- # Create message queue for the agent- self.message_queues[agent_id] = queue.Queue()-- # Store message handler- self.message_handlers[agent_id] = message_handler-- logger.info(f"Agent {agent_id} successfully registered with coordination system")- return True-- except Exception as e:- logger.error(f"Error registering agent {agent_id}: {str(e)}")- return False-- def unregister_agent(self, agent_id: str) -> bool:- """Unregister an agent from the coordination system"""- try:- if agent_id not in self.registered_agents:- logger.warning(f"Agent {agent_id} not registered")- return False-- # Remove agent registration- del self.registered_agents[agent_id]- del self.message_queues[agent_id]- del self.message_handlers[agent_id]-- logger.info(f"Agent {agent_id} successfully unregistered")- return True-- except Exception as e:- logger.error(f"Error unregistering agent {agent_id}: {str(e)}")- return False-- def send_message(- self,- sender: str,- recipients: List[str],- message_type: MessageType,- priority: Priority,- data: Dict[str, Any],- metadata: Optional[Dict[str, Any]] = None,- requires_response: bool = False,- correlation_id: Optional[str] = None- ) -> bool:- """- Send message from one agent to other agents-- Args:- sender: ID of sending agent- recipients: List of recipient agent IDs- message_type: Type of message being sent- priority: Priority level of message- data: Message data payload- metadata: Additional metadata- requires_response: Whether response is required- correlation_id: Correlation ID for request-response tracking-- Returns:- True if message queued successfully, False otherwise- """- try:- # Validate sender and recipients- if sender not in self.registered_agents:- logger.error(f"Sender {sender} not registered")- return False-- for recipient in recipients:- if recipient not in self.registered_agents:- logger.warning(f"Recipient {recipient} not registered")-- # Create message- message = AgentMessage(- id=self._generate_message_id(),- sender=sender,- recipients=recipients,- message_type=message_type,- priority=priority,- timestamp=datetime.now(),- data=data,- metadata=metadata or {},- requires_response=requires_response,- correlation_id=correlation_id- )-- # Calculate priority score for queue (lower = higher priority)- priority_score = self._calculate_priority_score(priority)-- # Add to priority queue- self.message_queue.put((priority_score, message))-- logger.info(f"Message from {sender} queued for {len(recipients)} recipients")- return True-- except Exception as e:- logger.error(f"Error sending message from {sender}: {str(e)}")- return False-- def broadcast_insights(- self,- agent_id: str,- insights: List[Dict[str, Any]],- priority: Priority = Priority.NORMAL- ) -> bool:- """- Broadcast strategic insights from an agent to all other agents-- Args:- agent_id: ID of agent broadcasting insights- insights: List of strategic insights to share- priority: Priority level of broadcast-- Returns:- True if broadcast successful, False otherwise- """- try:- if agent_id not in self.registered_agents:- logger.error(f"Agent {agent_id} not registered for insight broadcast")- return False-- # Update shared state with new insights- with self.state_lock:- if agent_id not in self.shared_state.agent_insights:- self.shared_state.agent_insights[agent_id] = []-- self.shared_state.agent_insights[agent_id].extend(insights)- self.shared_state.last_updated = datetime.now()-- # Broadcast to all other agents- other_agents = [aid for aid in self.registered_agents.keys() if aid != agent_id]-- message_data = {- "insights": insights,- "agent_focus": self._get_agent_focus_area(agent_id),- "strategic_implications": self._extract_strategic_implications(insights)- }-- return self.send_message(- sender=agent_id,- recipients=other_agents,- message_type=MessageType.INSIGHT_SHARING,- priority=priority,- data=message_data- )-- except Exception as e:- logger.error(f"Error broadcasting insights from {agent_id}: {str(e)}")- return False-- def request_coordination(- self,- requesting_agent: str,- target_agents: List[str],- coordination_request: Dict[str, Any],- priority: Priority = Priority.HIGH- ) -> str:- """- Request coordination with specific agents for collaborative analysis-- Args:- requesting_agent: ID of agent requesting coordination- target_agents: List of agents to coordinate with- coordination_request: Details of coordination request- priority: Priority level of request-- Returns:- Coordination ID for tracking the request- """- try:- coordination_id = self._generate_coordination_id()-- # Add to coordination requests in shared state- with self.coordination_lock:- self.shared_state.coordination_requests.append({- "id": coordination_id,- "requesting_agent": requesting_agent,- "target_agents": target_agents,- "request_data": coordination_request,- "status": "pending",- "created_at": datetime.now(),- "priority": priority.value- })-- # Send coordination request to target agents- message_data = {- "coordination_id": coordination_id,- "coordination_request": coordination_request,- "requested_by": requesting_agent,- "coordination_type": coordination_request.get("type", "collaborative_analysis"),- "analysis_focus": coordination_request.get("focus", "regional_balance"),- "timeline": coordination_request.get("timeline", "immediate")- }-- success = self.send_message(- sender=requesting_agent,- recipients=target_agents,- message_type=MessageType.COORDINATION_REQUEST,- priority=priority,- data=message_data,- requires_response=True- )-- if success:- logger.info(f"Coordination request {coordination_id} sent to {len(target_agents)} agents")- return coordination_id- else:- return None-- except Exception as e:- logger.error(f"Error requesting coordination from {requesting_agent}: {str(e)}")- return None-- def detect_conflicts(self) -> List[Dict[str, Any]]:- """- Detect conflicting recommendations or analyses across agents-- Returns:- List of detected conflicts with details- """- conflicts = []-- try:- # Get latest insights from all agents- all_insights = {}- with self.state_lock:- for agent_id, insights in self.shared_state.agent_insights.items():- if insights:- # Get most recent insights- recent_insights = sorted(insights, key=lambda x: x.get("timestamp", datetime.min), reverse=True)- if recent_insights:- all_insights[agent_id] = recent_insights[0]-- # Check for conflicts in recommendations- recommendations = {}- for agent_id, insight in all_insights.items():- if "recommendations" in insight.get("data", {}):- recommendations[agent_id] = insight["data"]["recommendations"]-- # Find conflicting recommendations- conflicts = self._identify_recommendation_conflicts(recommendations)-- # Check for conflicting strategic assessments- assessments = {}- for agent_id, insight in all_insights.items():- if "strategic_assessment" in insight.get("data", {}):- assessments[agent_id] = insight["data"]["strategic_assessment"]-- strategic_conflicts = self._identify_strategic_conflicts(assessments)-- # Combine all conflicts- all_conflicts = conflicts + strategic_conflicts-- # Alert relevant agents about conflicts- if all_conflicts:- self._broadcast_conflict_alerts(all_conflicts)-- return all_conflicts-- except Exception as e:- logger.error(f"Error detecting conflicts: {str(e)}")- return []-- def process_coordination_results(- self,- coordination_id: str,- participating_agents: List[str],- individual_results: Dict[str, Dict[str, Any]]- ) -> CoordinationResult:- """- Process and synthesize results from coordinated analysis-- Args:- coordination_id: ID of coordination request- participating_agents: List of agents that participated- individual_results: Individual analysis results from each agent-- Returns:- Coordinated analysis result with synthesis- """- try:- # Update coordination request status- with self.coordination_lock:- for req in self.shared_state.coordination_requests:- if req["id"] == coordination_id:- req["status"] = "completed"- req["completed_at"] = datetime.now()- break-- # Synthesize individual results- combined_insights = self._synthesize_agent_results(individual_results)-- # Generate consensus recommendations- consensus_recommendations = self._generate_consensus_recommendations(individual_results)-- # Identify conflicting recommendations- conflicting_recommendations = self._identify_conflicting_recommendations(individual_results)-- # Create coordination result- result = CoordinationResult(- coordinated_by=participing_agents[0] if participating_agents else "unknown",- participating_agents=participating_agents,- combined_insights=combined_insights,- consensus_recommendations=consensus_recommendations,- conflicting_recommendations=conflicting_recommendations,- coordination_success=len(participating_agents) > 1- )-- # Store in coordination history- self.coordination_history.append(result)-- # Broadcast result to all participating agents- self._broadcast_coordination_result(coordination_id, result)-- logger.info(f"Coordination {coordination_id} completed with {len(participating_agents)} agents")- return result-- except Exception as e:- logger.error(f"Error processing coordination results for {coordination_id}: {str(e)}")- return CoordinationResult(- coordinated_by="error",- participating_agents=[],- combined_insights={},- consensus_recommendations=["Coordination processing failed"],- conflicting_recommendations=[],- coordination_success=False- )-- def get_shared_chessboard_state(self) -> SharedChessboardState:- """Get current shared chessboard state"""- with self.state_lock:- return self.shared_state-- def get_agent_status(self, agent_id: Optional[str] = None) -> Dict[str, Any]:- """Get status of specific agent or all agents"""- if agent_id:- if agent_id in self.registered_agents:- return self.registered_agents[agent_id]- else:- return {"error": f"Agent {agent_id} not registered"}- else:- return self.registered_agents.copy()-- def get_coordination_history(self, limit: Optional[int] = None) -> List[CoordinationResult]:- """Get coordination history"""- if limit:- return self.coordination_history[-limit:]- return self.coordination_history.copy()-- # Private helper methods- def _generate_message_id(self) -> str:- """Generate unique message ID"""- import uuid- return str(uuid.uuid4())-- def _generate_coordination_id(self) -> str:- """Generate unique coordination ID"""- import uuid- return f"coord_{str(uuid.uuid4())[:8]}"-- def _calculate_priority_score(self, priority: Priority) -> int:- """Calculate priority score for queue (lower = higher priority)"""- priority_scores = {- Priority.CRITICAL: 1,- Priority.HIGH: 2,- Priority.NORMAL: 3,- Priority.LOW: 4- }- return priority_scores.get(priority, 3)-- def _get_agent_focus_area(self, agent_id: str) -> str:- """Get primary focus area for an agent"""- agent_focuses = {- "eurasian_chessboard_master": "global_balance",- "democratic_bridgehead": "european_integration",- "black_hole": "post_soviet_russia",- "eurasian_balkans": "central_asia_caucasus",- "far_eastern_anchor": "east_asian_balance",- "geostrategic_players": "great_power_dynamics",- "geopolitical_pivots": "pivot_state_leverage",- "american_hegemony": "us_primacy_maintenance"- }- return agent_focuses.get(agent_id, "unknown")-- def _extract_strategic_implications(self, insights: List[Dict[str, Any]]) -> List[str]:- """Extract strategic implications from insights"""- implications = []- for insight in insights:- if "implications" in insight:- if isinstance(insight["implications"], list):- implications.extend(insight["implications"])- else:- implications.append(insight["implications"])- return implications-- def _identify_recommendation_conflicts(self, recommendations: Dict[str, List[str]]) -> List[Dict[str, Any]]:- """Identify conflicting recommendations across agents"""- conflicts = []-- # Convert recommendations to sets for comparison- rec_sets = {agent: set(recs) for agent, recs in recommendations.items()}-- # Check for opposing recommendations- opposing_pairs = [- ("escalate", "deescalate"),- ("contain", "engage"),- ("confront", "cooperate"),- ("isolate", "integrate"),- ("military_solution", "diplomatic_solution")- ]-- for agent1, recs1 in recommendations.items():- for agent2, recs2 in recommendations.items():- if agent1 >= agent2: # Avoid duplicate comparisons- continue-- for opposing_pair in opposing_pairs:- if any(opposing_pair[0] in rec for rec in [recs1, recs2]) and \- any(opposing_pair[1] in rec for rec in [recs1, recs2]):- conflicts.append({- "type": "opposing_recommendations",- "agents": [agent1, agent2],- "conflicting_recommendations": [- {"agent": agent1, "recs": [r for r in recs1 if opposing_pair[0] in r]},- {"agent": agent2, "recs": [r for r in recs2 if opposing_pair[1] in r]}- ],- "severity": "high"- })-- return conflicts-- def _identify_strategic_conflicts(self, assessments: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:- """Identify conflicting strategic assessments"""- conflicts = []-- # Check for conflicting stability assessments- stability_assessments = {}- for agent_id, assessment in assessments.items():- if "stability_level" in assessment:- stability_assessments[agent_id] = assessment["stability_level"]-- # Check for opposing stability views- if "stable" in stability_assessments.values() and "unstable" in stability_assessments.values():- stable_agents = [a for a, s in stability_assessments.items() if s == "stable"]- unstable_agents = [a for a, s in stability_assessments.items() if s == "unstable"]-- conflicts.append({- "type": "stability_assessment_conflict",- "agents": stable_agents + unstable_agents,- "conflict": "Different views on regional stability",- "severity": "medium"- })-- return conflicts-- def _broadcast_conflict_alerts(self, conflicts: List[Dict[str, Any]]) -> None:- """Broadcast conflict alerts to relevant agents"""- try:- # Identify all agents involved in conflicts- involved_agents = set()- for conflict in conflicts:- involved_agents.update(conflict.get("agents", []))-- if involved_agents:- message_data = {- "conflicts": conflicts,- "alert_level": "high" if any(c.get("severity") == "high" for c in conflicts) else "medium",- "resolution_suggestion": "Coordinate to resolve conflicting assessments",- "requires_coordination": True- }-- self.send_message(- sender="coordination_system",- recipients=list(involved_agents),- message_type=MessageType.CONFLICT_ALERT,- priority=Priority.HIGH,- data=message_data- )-- except Exception as e:- logger.error(f"Error broadcasting conflict alerts: {str(e)}")-- def _synthesize_agent_results(self, individual_results: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:- """Synthesize individual agent results into combined insights"""- combined_insights = {- "participating_agents": list(individual_results.keys()),- "analysis_domains": {},- "key_findings": [],- "common_themes": [],- "data_sources": []- }-- # Extract analysis domains and key findings- for agent_id, result in individual_results.items():- if "assessment_type" in result:- combined_insights["analysis_domains"][agent_id] = result["assessment_type"]-- if "key_findings" in result:- combined_insights["key_findings"].extend(result["key_findings"])-- if "data_sources" in result:- combined_insights["data_sources"].extend(result["data_sources"])-- # Identify common themes across agents- all_recommendations = []- for result in individual_results.values():- if "strategic_recommendations" in result:- all_recommendations.extend(result["strategic_recommendations"])-- # Find common themes using keyword analysis- common_themes = self._extract_common_themes(all_recommendations)- combined_insights["common_themes"] = common_themes-- return combined_insights-- def _generate_consensus_recommendations(self, individual_results: Dict[str, Dict[str, Any]]) -> List[str]:- """Generate consensus recommendations from individual agent results"""- all_recommendations = []-- # Collect all recommendations- for result in individual_results.values():- if "strategic_recommendations" in result:- all_recommendations.extend(result["strategic_recommendations"])-- # Count frequency of similar recommendations- recommendation_counts = {}- for rec in all_recommendations:- # Simple similarity check - could be enhanced with NLP- similar_recs = [r for r in recommendation_counts.keys()- if self._are_recommendations_similar(r, rec)]-- if similar_recs:- # Use existing similar recommendation key- existing_key = similar_recs[0]- recommendation_counts[existing_key] += 1- else:- recommendation_counts[rec] = 1-- # Sort by frequency and return top recommendations- sorted_recommendations = sorted(recommendation_counts.items(),- key=lambda x: x[1], reverse=True)-- consensus_recommendations = [rec for rec, count in sorted_recommendations[:5]]-- return consensus_recommendations-- def _identify_conflicting_recommendations(self, individual_results: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:- """Identify recommendations that conflict across agents"""- conflicts = []- all_recommendations = {}-- # Collect all recommendations by agent- for agent_id, result in individual_results.items():- if "strategic_recommendations" in result:- all_recommendations[agent_id] = result["strategic_recommendations"]-- # Use the conflict detection logic from earlier- return self._identify_recommendation_conflicts(all_recommendations)-- def _extract_common_themes(self, recommendations: List[str]) -> List[str]:- """Extract common themes from list of recommendations"""- # Simple keyword-based theme extraction- theme_keywords = {- "balance_of_power": ["balance", "equilibrium", "power", "hegemony", "containment"],- "alliance_cooperation": ["alliance", "cooperation", "partnership", "coordination"],- "economic_strategy": ["economic", "trade", "investment", "development"],- "military_deterrence": ["military", "deterrence", "defense", "security"],- "diplomatic_engagement": ["diplomatic", "engagement", "dialogue", "negotiation"]- }-- theme_counts = {theme: 0 for theme in theme_keywords}-- for rec in recommendations:- rec_lower = rec.lower()- for theme, keywords in theme_keywords.items():- if any(keyword in rec_lower for keyword in keywords):- theme_counts[theme] += 1-- # Return themes with most mentions- sorted_themes = sorted(theme_counts.items(), key=lambda x: x[1], reverse=True)- return [theme for theme, count in sorted_themes if count > 0]-- def _are_recommendations_similar(self, rec1: str, rec2: str) -> bool:- """Check if two recommendations are similar"""- # Simple similarity based on shared keywords- rec1_words = set(rec1.lower().split())- rec2_words = set(rec2.lower().split())-- # Check if they share significant keywords- common_words = rec1_words & rec2_words- total_words = rec1_words | rec2_words-- # Consider similar if they share >30% of words- similarity_ratio = len(common_words) / len(total_words) if total_words else 0- return similarity_ratio > 0.3-- def _broadcast_coordination_result(self, coordination_id: str, result: CoordinationResult) -> None:- """Broadcast coordination result to participating agents"""- try:- message_data = {- "coordination_id": coordination_id,- "result": result,- "success": result.coordination_success,- "consensus_count": len(result.consensus_recommendations),- "conflict_count": len(result.conflicting_recommendations)- }-- self.send_message(- sender="coordination_system",- recipients=result.participating_agents,- message_type=MessageType.RESPONSE,- priority=Priority.NORMAL,- data=message_data- )-- except Exception as e:- logger.error(f"Error broadcasting coordination result: {str(e)}")-- def start_message_processing(self) -> None:- """Start background thread for processing messages"""- def process_messages():- while True:- try:- if not self.message_queue.empty():- _, message = self.message_queue.get()- self._route_message(message)- else:- import time- time.sleep(0.1) # Small delay to prevent busy waiting- except Exception as e:- logger.error(f"Error in message processing: {str(e)}")- import time- time.sleep(1)-- # Start background thread- processing_thread = threading.Thread(target=process_messages, daemon=True)- processing_thread.start()- logger.info("Message processing thread started")-- def _route_message(self, message: AgentMessage) -> None:- """Route message to appropriate recipients"""- try:- for recipient in message.recipients:- if recipient in self.message_queues:- self.message_queues[recipient].put(message)-- # Update agent status- if recipient in self.registered_agents:- self.registered_agents[recipient]["message_count"] += 1- self.registered_agents[recipient]["last_seen"] = datetime.now()-- # Call message handler if exists- if recipient in self.message_handlers:- try:- self.message_handlers[recipient](message)- except Exception as e:- logger.error(f"Error in message handler for {recipient}: {str(e)}")- else:- logger.warning(f"Recipient {recipient} not found in message queues")-- except Exception as e:- logger.error(f"Error routing message: {str(e)}")--# Global coordination system instance-_coordination_system = None--def get_coordination_system() -> AgentCoordinationSystem:- """Get or create the global coordination system instance"""- global _coordination_system- if _coordination_system is None:- _coordination_system = AgentCoordinationSystem()- _coordination_system.start_message_processing()- return _coordination_system--# Example usage and integration functions-def register_chessboard_agent(agent_id: str, message_handler: Callable[[AgentMessage], None]) -> bool:- """Convenience function to register a Grand Chessboard agent"""- coordination_system = get_coordination_system()- return coordination_system.register_agent(agent_id, message_handler)--def share_agent_insights(agent_id: str, insights: List[Dict[str, Any]], priority: Priority = Priority.NORMAL) -> bool:- """Convenience function for agents to share insights"""- coordination_system = get_coordination_system()- return coordination_system.broadcast_insights(agent_id, insights, priority)--def request_agent_coordination(- requesting_agent: str,- target_agents: List[str],- coordination_request: Dict[str, Any],- priority: Priority = Priority.HIGH-) -> Optional[str]:- """Convenience function to request coordination with other agents"""- coordination_system = get_coordination_system()- return coordination_system.request_coordination(- requesting_agent, target_agents, coordination_request, priority- )--def get_shared_chessboard_state() -> SharedChessboardState:- """Convenience function to get current shared chessboard state"""- coordination_system = get_coordination_system()- return coordination_system.get_shared_chessboard_state()--# Example usage for testing-if __name__ == "__main__":- # Example coordination system usage- def sample_message_handler(message: AgentMessage) -> None:- print(f"Agent {message.sender} sent message type {message.message_type}")- print(f"Message data: {message.data}")-- # Register agents- coordination_system = get_coordination_system()- coordination_system.register_agent("democratic_bridgehead", sample_message_handler)- coordination_system.register_agent("black_hole", sample_message_handler)- coordination_system.register_agent("eurasian_balkans", sample_message_handler)-- # Example insight sharing- insights = [- {"finding": "NATO expansion enhances European stability", "impact": "high"},- {"finding": "Chinese influence increasing in Central Asia", "impact": "medium"}- ]-- share_agent_insights("democratic_bridgehead", insights)-- # Example coordination request- coordination_request = {- "type": "collaborative_analysis",- "focus": "eurasian_balance_of_power",- "timeline": "2_days",- "specific_question": "How will NATO expansion affect Russian strategic calculations?"- }-- coordination_id = request_agent_coordination(- requesting_agent="eurasian_chessboard_master",- target_agents=["democratic_bridgehead", "black_hole"],- coordination_request=coordination_request- )-- print(f"Coordination requested with ID: {coordination_id}")- print("Coordination system active and processing messages")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/balance_of_power.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/balance_of_power.pydeleted file mode 100644index 7827ba0c8..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/balance_of_power.py+++ /dev/null@@ -1,979 +0,0 @@-"""-BALANCE OF POWER CALCULATOR-Geostrategic Module for Grand Chessboard Agents--This module implements Brzezinski's balance of power analysis framework,-calculating and predicting changes in global and regional power distributions-across the Eurasian chessboard.-"""--import logging-from typing import Dict, List, Any, Tuple, Optional-from dataclasses import dataclass-from enum import Enum-import math--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class PowerType(Enum):- """Types of power in geopolitical analysis"""- MILITARY = "military"- ECONOMIC = "economic"- TECHNOLOGICAL = "technological"- DIPLOMATIC = "diplomatic"- CULTURAL = "cultural"--class PowerLevel(Enum):- """Relative power levels"""- DOMINANT = "dominant" # > 0.7 share- LEADING = "leading" # 0.4 - 0.7 share- MAJOR = "major" # 0.2 - 0.4 share- REGIONAL = "regional" # 0.1 - 0.2 share- MINOR = "minor" # < 0.1 share--@dataclass-class PowerMetrics:- """Metrics for a specific power's capabilities"""- military_capability: float # 0-1 scale- economic_strength: float # 0-1 scale- technological_advantage: float # 0-1 scale- diplomatic_influence: float # 0-1 scale- cultural_reach: float # 0-1 scale- overall_power: float # Composite score--@dataclass-class PowerBalance:- """Power balance assessment for a region or globally"""- powers: Dict[str, PowerMetrics]- distribution: Dict[str, float] # Power shares- concentration_index: float # HHI for power concentration- stability_level: str # stable, competitive, volatile- hegemony_risk: str # low, medium, high--class BalanceOfPowerCalculator:- """- Calculates and predicts changes in global and regional power balances- following Brzezinski's balance of power framework- """-- def __init__(self):- """Initialize the balance of power calculator"""- self.module_id = "balance_of_power_calculator"-- # Power weights based on Brzezinski's framework- self.power_weights = {- PowerType.MILITARY: 0.30, # Military power is primary- PowerType.ECONOMIC: 0.25, # Economic foundation- PowerType.TECHNOLOGICAL: 0.20, # Modern warfare factor- PowerType.DIPLOMATIC: 0.15, # Alliance influence- PowerType.CULTURAL: 0.10 # Soft power- }-- # Great powers per Brzezinski- self.great_powers = [- "united_states", "china", "russia",- "japan", "germany", "france", "india"- ]-- # Regional power groupings- self.regional_powers = {- "europe": ["germany", "france", "united_kingdom", "italy"],- "east_asia": ["china", "japan", "south_korea"],- "south_asia": ["india", "pakistan"],- "middle_east": ["turkey", "iran", "saudi_arabia", "israel"],- "central_asia": ["kazakhstan", "uzbekistan"],- "russia_near_abroad": ["russia"]- }-- def calculate_global_power_balance(- self,- military_data: Dict[str, Any],- economic_data: Dict[str, Any],- diplomatic_data: Dict[str, Any],- technological_data: Optional[Dict[str, Any]] = None- ) -> PowerBalance:- """- Calculate current global power distribution-- Args:- military_data: Military capabilities by country- economic_data: Economic indicators by country- diplomatic_data: Diplomatic influence data- technological_data: Technology capabilities data-- Returns:- PowerBalance object with current distribution and stability assessment- """- try:- logger.info("Calculating global power balance")-- power_metrics = {}-- # Calculate power metrics for each great power- for power in self.great_powers:- power_metrics[power] = self._calculate_power_metrics(- power, military_data, economic_data, diplomatic_data, technological_data- )-- # Calculate power distribution (shares)- total_power = sum(metrics.overall_power for metrics in power_metrics.values())- distribution = {- power: metrics.overall_power / total_power- for power, metrics in power_metrics.items()- }-- # Calculate concentration index (Herfindahl-Hirschman Index)- concentration_index = sum(share ** 2 for share in distribution.values())-- # Assess stability level- stability_level = self._assess_balance_stability(distribution, concentration_index)-- # Assess hegemony risk- hegemony_risk = self._assess_hegemony_risk(distribution, concentration_index)-- return PowerBalance(- powers=power_metrics,- distribution=distribution,- concentration_index=concentration_index,- stability_level=stability_level,- hegemony_risk=hegemony_risk- )-- except Exception as e:- logger.error(f"Error calculating global power balance: {str(e)}")- raise-- def calculate_regional_power_balance(- self,- region: str,- military_data: Dict[str, Any],- economic_data: Dict[str, Any],- diplomatic_data: Dict[str, Any]- ) -> PowerBalance:- """- Calculate power balance for specific Eurasian region-- Args:- region: Region identifier (europe, east_asia, central_asia, etc.)- military_data: Regional military capabilities- economic_data: Regional economic data- diplomatic_data: Regional diplomatic influence-- Returns:- PowerBalance for the specified region- """- try:- logger.info(f"Calculating power balance for region: {region}")-- # Get relevant powers for this region- regional_powers = self._get_regional_powers(region)- power_metrics = {}-- # Calculate power metrics for regional powers- for power in regional_powers:- power_metrics[power] = self._calculate_power_metrics(- power, military_data, economic_data, diplomatic_data- )-- # Calculate power distribution- total_power = sum(metrics.overall_power for metrics in power_metrics.values())- distribution = {- power: metrics.overall_power / total_power- for power, metrics in power_metrics.items()- }-- # Calculate concentration index- concentration_index = sum(share ** 2 for share in distribution.values())-- # Assess regional stability- stability_level = self._assess_regional_stability(region, distribution)-- # Assess regional hegemony risk- hegemony_risk = self._assess_regional_hegemony_risk(distribution, concentration_index)-- return PowerBalance(- powers=power_metrics,- distribution=distribution,- concentration_index=concentration_index,- stability_level=stability_level,- hegemony_risk=hegemony_risk- )-- except Exception as e:- logger.error(f"Error calculating regional power balance for {region}: {str(e)}")- raise-- def analyze_power_shifts(- self,- current_balance: PowerBalance,- historical_balance: PowerBalance,- time_period: str = "year"- ) -> Dict[str, Any]:- """- Analyze power shifts between different time periods-- Args:- current_balance: Current power balance- historical_balance: Previous power balance- time_period: Time period for comparison-- Returns:- Analysis of power shifts and trends- """- try:- logger.info(f"Analyzing power shifts over {time_period}")-- power_shifts = {}-- # Calculate shifts for each power- all_powers = set(current_balance.distribution.keys()) | set(historical_balance.distribution.keys())-- for power in all_powers:- current_share = current_balance.distribution.get(power, 0)- historical_share = historical_balance.distribution.get(power, 0)-- shift = current_share - historical_share- shift_percentage = (shift / historical_share * 100) if historical_share > 0 else 0-- power_shifts[power] = {- "absolute_change": shift,- "percentage_change": shift_percentage,- "direction": "gaining" if shift > 0 else "losing" if shift < 0 else "stable",- "significance": self._assess_shift_significance(shift, time_period)- }-- # Identify major power shifts- major_shifts = {- power: data for power, data in power_shifts.items()- if data["significance"] in ["major", "significant"]- }-- # Analyze balance changes- stability_change = self._analyze_stability_change(- current_balance.stability_level,- historical_balance.stability_level- )-- concentration_change = current_balance.concentration_index - historical_balance.concentration_index-- return {- "power_shifts": power_shifts,- "major_shifts": major_shifts,- "stability_change": stability_change,- "concentration_change": concentration_change,- "trend_analysis": self._analyze_power_trends(power_shifts, time_period),- "implications": self._analyze_shift_implications(major_shifts, concentration_change)- }-- except Exception as e:- logger.error(f"Error analyzing power shifts: {str(e)}")- raise-- def project_future_balance(- self,- current_balance: PowerBalance,- growth_projections: Dict[str, Dict[str, float]],- time_horizon: int = 5- ) -> Dict[str, Any]:- """- Project future power balance based on growth projections-- Args:- current_balance: Current power balance- growth_projections: Growth rates for different power types by country- time_horizon: Years to project forward-- Returns:- Projected future power balance scenarios- """- try:- logger.info(f"Projecting power balance {time_horizon} years forward")-- projected_balances = []-- # Project year by year- for year in range(1, time_horizon + 1):- projected_powers = {}-- for power, current_metrics in current_balance.powers.items():- # Get growth projections for this power- power_growth = growth_projections.get(power, {})-- # Project each power component- projected_military = self._project_power_component(- current_metrics.military_capability,- power_growth.get("military_growth", 0),- year- )-- projected_economic = self._project_power_component(- current_metrics.economic_strength,- power_growth.get("economic_growth", 0),- year- )-- projected_technological = self._project_power_component(- current_metrics.technological_advantage,- power_growth.get("tech_growth", 0),- year- )-- projected_diplomatic = self._project_power_component(- current_metrics.diplomatic_influence,- power_growth.get("diplomatic_growth", 0),- year- )-- # Calculate projected overall power- projected_overall = self._calculate_composite_power(- projected_military,- projected_economic,- projected_technological,- projected_diplomatic- )-- projected_powers[power] = PowerMetrics(- military_capability=projected_military,- economic_strength=projected_economic,- technological_advantage=projected_technological,- diplomatic_influence=projected_diplomatic,- cultural_reach=current_metrics.cultural_reach, # Assume stable- overall_power=projected_overall- )-- # Calculate projected distribution- total_power = sum(metrics.overall_power for metrics in projected_powers.values())- projected_distribution = {- power: metrics.overall_power / total_power- for power, metrics in projected_powers.items()- }-- projected_balance = PowerBalance(- powers=projected_powers,- distribution=projected_distribution,- concentration_index=sum(share ** 2 for share in projected_distribution.values()),- stability_level=self._assess_balance_stability(projected_distribution),- hegemony_risk=self._assess_hegemony_risk(projected_distribution)- )-- projected_balances.append({- "year": year,- "balance": projected_balance- })-- # Analyze trends and critical thresholds- trend_analysis = self._analyze_projection_trends(projected_balances)- critical_thresholds = self._identify_critical_thresholds(projected_balances)-- return {- "projections": projected_balances,- "trend_analysis": trend_analysis,- "critical_thresholds": critical_thresholds,- "scenarios": self._generate_balance_scenarios(projected_balances),- "recommendations": self._generate_balance_recommendations(projected_balances)- }-- except Exception as e:- logger.error(f"Error projecting future balance: {str(e)}")- raise-- def _calculate_power_metrics(- self,- power: str,- military_data: Dict[str, Any],- economic_data: Dict[str, Any],- diplomatic_data: Dict[str, Any],- technological_data: Optional[Dict[str, Any]] = None- ) -> PowerMetrics:- """Calculate comprehensive power metrics for a specific power"""-- # Extract military capability- military_capability = self._assess_military_capability(power, military_data)-- # Extract economic strength- economic_strength = self._assess_economic_strength(power, economic_data)-- # Extract technological advantage- technological_advantage = self._assess_technological_advantage(- power, technological_data or {}- )-- # Extract diplomatic influence- diplomatic_influence = self._assess_diplomatic_influence(power, diplomatic_data)-- # Cultural reach (simplified assessment)- cultural_reach = self._assess_cultural_reach(power)-- # Calculate composite overall power- overall_power = self._calculate_composite_power(- military_capability, economic_strength,- technological_advantage, diplomatic_influence, cultural_reach- )-- return PowerMetrics(- military_capability=military_capability,- economic_strength=economic_strength,- technological_advantage=technological_advantage,- diplomatic_influence=diplomatic_influence,- cultural_reach=cultural_reach,- overall_power=overall_power- )-- def _assess_military_capability(self, power: str, military_data: Dict[str, Any]) -> float:- """Assess military capability on 0-1 scale"""-- # Get military data for this power- power_military = military_data.get(power, {})-- # Key factors (normalized to 0-1)- personnel_factor = self._normalize_value(power_military.get("personnel", 0), 0, 3000000)- equipment_factor = self._normalize_value(power_military.get("equipment_score", 0), 0, 100)- technology_factor = self._normalize_value(power_military.get("technology_level", 0), 0, 10)- projection_factor = self._normalize_value(power_military.get("projection_capability", 0), 0, 10)- nuclear_factor = 1.0 if power_military.get("nuclear_capability", False) else 0.5-- # Weighted average (military-focused weighting)- military_capability = (- personnel_factor * 0.25 +- equipment_factor * 0.25 +- technology_factor * 0.20 +- projection_factor * 0.20 +- nuclear_factor * 0.10- )-- return min(military_capability, 1.0)-- def _assess_economic_strength(self, power: str, economic_data: Dict[str, Any]) -> float:- """Assess economic strength on 0-1 scale"""-- power_economic = economic_data.get(power, {})-- # Key economic factors- gdp_factor = self._normalize_log_value(power_economic.get("gdp", 0), 1000000000, 25000000000000)- growth_factor = self._normalize_value(power_economic.get("growth_rate", 0), -5, 10)- trade_factor = self._normalize_log_value(power_economic.get("trade_volume", 0), 100000000, 10000000000)- technology_factor = self._normalize_log_value(power_economic.get("tech_investment", 0), 1000000000, 1000000000000)- energy_factor = self._normalize_value(power_economic.get("energy_independence", 0), 0, 1)-- economic_strength = (- gdp_factor * 0.35 +- growth_factor * 0.20 +- trade_factor * 0.20 +- technology_factor * 0.15 +- energy_factor * 0.10- )-- return min(economic_strength, 1.0)-- def _assess_technological_advantage(self, power: str, tech_data: Dict[str, Any]) -> float:- """Assess technological advantage on 0-1 scale"""-- power_tech = tech_data.get(power, {})-- # Technology indicators- innovation_factor = self._normalize_value(power_tech.get("innovation_index", 0), 0, 100)- research_factor = self._normalize_log_value(power_tech.get("rd_spending", 0), 10000000000, 800000000000)- digital_factor = self._normalize_value(power_tech.get("digital_infrastructure", 0), 0, 100)- ai_factor = self._normalize_value(power_tech.get("ai_capability", 0), 0, 10)- space_factor = self._normalize_value(power_tech.get("space_capability", 0), 0, 10)-- technological_advantage = (- innovation_factor * 0.25 +- research_factor * 0.25 +- digital_factor * 0.20 +- ai_factor * 0.15 +- space_factor * 0.15- )-- return min(technological_advantage, 1.0)-- def _assess_diplomatic_influence(self, power: str, diplomatic_data: Dict[str, Any]) -> float:- """Assess diplomatic influence on 0-1 scale"""-- power_diplomatic = diplomatic_data.get(power, {})-- # Diplomatic indicators- un_influence = self._normalize_value(power_diplomatic.get("un_influence", 0), 0, 10)- alliance_strength = self._normalize_value(power_diplomatic.get("alliance_strength", 0), 0, 10)- soft_power = self._normalize_value(power_diplomatic.get("soft_power_index", 0), 0, 100)- mediation_role = self._normalize_value(power_diplomatic.get("mediation_role", 0), 0, 10)- institutional_influence = self._normalize_value(power_diplomatic.get("institutional_power", 0), 0, 10)-- diplomatic_influence = (- un_influence * 0.20 +- alliance_strength * 0.30 +- soft_power * 0.25 +- mediation_role * 0.10 +- institutional_influence * 0.15- )-- return min(diplomatic_influence, 1.0)-- def _assess_cultural_reach(self, power: str) -> float:- """Assess cultural reach on 0-1 scale"""-- # Cultural influence mapping (simplified)- cultural_scores = {- "united_states": 0.9, # Global cultural dominance- "china": 0.6, # Growing cultural influence- "france": 0.5, # Traditional cultural power- "united_kingdom": 0.5, # Historical cultural reach- "japan": 0.4, # Regional cultural influence- "india": 0.4, # Growing cultural influence- "germany": 0.3, # Economic cultural influence- "russia": 0.3, # Declining but present- }-- return cultural_scores.get(power, 0.2) # Default baseline-- def _calculate_composite_power(- self,- military: float,- economic: float,- technological: float,- diplomatic: float,- cultural: float = 0.0- ) -> float:- """Calculate composite overall power score"""-- return (- military * self.power_weights[PowerType.MILITARY] +- economic * self.power_weights[PowerType.ECONOMIC] +- technological * self.power_weights[PowerType.TECHNOLOGICAL] +- diplomatic * self.power_weights[PowerType.DIPLOMATIC] +- cultural * self.power_weights[PowerType.CULTURAL]- )-- def _assess_balance_stability(- self,- distribution: Dict[str, float],- concentration_index: float- ) -> str:- """Assess the stability of the current power balance"""-- if concentration_index > 0.5:- return "volatile" # One power dominates- elif concentration_index > 0.3:- return "competitive" # Clear competition among top powers- elif concentration_index > 0.2:- return "stable" # Balanced distribution- else:- return "fragmented" # Many powers, no clear leader-- def _assess_hegemony_risk(- self,- distribution: Dict[str, float],- concentration_index: float- ) -> str:- """Assess the risk of a single power achieving hegemony"""-- # Find the largest power share- max_share = max(distribution.values()) if distribution else 0-- if max_share > 0.6:- return "high"- elif max_share > 0.4:- return "medium"- else:- return "low"-- def _normalize_value(self, value: float, min_val: float, max_val: float) -> float:- """Normalize a value to 0-1 scale"""- if max_val <= min_val:- return 0.0- return max(0.0, min(1.0, (value - min_val) / (max_val - min_val)))-- def _normalize_log_value(self, value: float, min_val: float, max_val: float) -> float:- """Normalize a value using log scale for better distribution"""- if value <= 0:- return 0.0- log_value = math.log10(value)- log_min = math.log10(min_val)- log_max = math.log10(max_val)- return self._normalize_value(log_value, log_min, log_max)-- def _get_regional_powers(self, region: str) -> List[str]:- """Get list of relevant powers for a specific region"""- # Include both regional powers and global powers with interests in region- regional = self.regional_powers.get(region, [])-- # Add great powers that have interests in the region- interested_powers = []- if region in ["europe", "middle_east", "russia_near_abroad"]:- interested_powers.extend(["united_states", "russia"])- if region in ["east_asia", "south_asia", "central_asia"]:- interested_powers.extend(["united_states", "china"])- if region == "europe":- interested_powers.extend(["germany", "france", "united_kingdom"])-- return list(set(regional + interested_powers))-- # Additional helper methods for advanced analysis- def _assess_shift_significance(self, shift: float, time_period: str) -> str:- """Assess the significance of a power shift"""-- if time_period == "year":- if abs(shift) > 0.05:- return "major"- elif abs(shift) > 0.02:- return "significant"- elif abs(shift) > 0.01:- return "moderate"- else:- return "minor"- elif time_period == "decade":- if abs(shift) > 0.15:- return "major"- elif abs(shift) > 0.08:- return "significant"- elif abs(shift) > 0.04:- return "moderate"- else:- return "minor"- else:- return "unknown"-- def _analyze_power_trends(- self,- power_shifts: Dict[str, Dict[str, Any]],- time_period: str- ) -> Dict[str, Any]:- """Analyze overall power trends from shift data"""-- gaining_powers = [p for p, data in power_shifts.items() if data["direction"] == "gaining"]- losing_powers = [p for p, data in power_shifts.items() if data["direction"] == "losing"]-- return {- "trend_direction": "fragmentation" if len(gaining_powers) > len(losing_powers) else "concentration",- "rising_powers": gaining_powers,- "declining_powers": losing_powers,- "major_trends": [p for p in gaining_powers + losing_powers- if power_shifts[p]["significance"] in ["major", "significant"]]- }-- def _analyze_shift_implications(- self,- major_shifts: Dict[str, Dict[str, Any]],- concentration_change: float- ) -> List[str]:- """Analyze strategic implications of major power shifts"""-- implications = []-- if concentration_change > 0.02:- implications.append("Increasing power concentration suggests rising hegemony risk")- elif concentration_change < -0.02:- implications.append("Decreasing concentration suggests more balanced power distribution")-- for power, shift_data in major_shifts.items():- if shift_data["direction"] == "gaining":- implications.append(f"{power.title()}'s rising power requires strategic attention")- else:- implications.append(f"{power.title()}'s declining power may create strategic opportunities")-- return implications-- # Additional implementation methods for advanced features- def _project_power_component(- self,- current_value: float,- growth_rate: float,- years: int- ) -> float:- """Project power component growth over time period"""- return current_value * ((1 + growth_rate / 100) ** years)-- def _analyze_projection_trends(self, projections: List[Dict[str, Any]]) -> Dict[str, Any]:- """Analyze trends in power balance projections"""-- if not projections:- return {}-- first_year = projections[0]- last_year = projections[-1]-- trend_changes = {}- for power in first_year["balance"].distribution:- initial_share = first_year["balance"].distribution.get(power, 0)- final_share = last_year["balance"].distribution.get(power, 0)- change = final_share - initial_share-- trend_changes[power] = {- "initial_share": initial_share,- "final_share": final_share,- "total_change": change,- "direction": "gaining" if change > 0 else "losing" if change < 0 else "stable"- }-- return {- "power_trends": trend_changes,- "dominant_trend": self._identify_dominant_trend(trend_changes),- "stability_evolution": self._track_stability_evolution(projections)- }-- def _identify_dominant_trend(self, trend_changes: Dict[str, Dict[str, Any]]) -> str:- """Identify the dominant trend in power evolution"""-- gaining_count = sum(1 for data in trend_changes.values() if data["direction"] == "gaining")- losing_count = sum(1 for data in trend_changes.values() if data["direction"] == "losing")-- if gaining_count > losing_count:- return "power_diffusion"- elif losing_count > gaining_count:- return "power_concentration"- else:- return "relative_stability"-- def _track_stability_evolution(self, projections: List[Dict[str, Any]]) -> List[str]:- """Track how stability evolves over projections"""-- stability_evolution = []- for projection in projections:- stability_evolution.append(projection["balance"].stability_level)-- return stability_evolution-- # Additional helper methods would be implemented for complete functionality- def _assess_regional_stability(self, region: str, distribution: Dict[str, float]) -> str:- """Assess stability for a specific region"""- # Simplified implementation - would be more sophisticated in production- concentration = max(distribution.values()) if distribution else 0-- if concentration > 0.6:- return "volatile"- elif concentration > 0.4:- return "competitive"- else:- return "stable"-- def _assess_regional_hegemony_risk(- self,- distribution: Dict[str, float],- concentration_index: float- ) -> str:- """Assess regional hegemony risk"""- max_share = max(distribution.values()) if distribution else 0-- if max_share > 0.7:- return "high"- elif max_share > 0.5:- return "medium"- else:- return "low"-- def _analyze_stability_change(self, current: str, historical: str) -> Dict[str, str]:- """Analyze change in stability level"""- if current == historical:- return {"status": "unchanged", "level": current}-- stability_levels = {"stable": 1, "competitive": 2, "volatile": 3, "fragmented": 4}-- current_level = stability_levels.get(current, 2)- historical_level = stability_levels.get(historical, 2)-- if current_level > historical_level:- return {"status": "degraded", "from": historical, "to": current}- else:- return {"status": "improved", "from": historical, "to": current}-- def _identify_critical_thresholds(self, projections: List[Dict[str, Any]]) -> List[Dict[str, Any]]:- """Identify when critical power thresholds are crossed"""- thresholds = []-- for i, projection in enumerate(projections):- year = projection["year"]- balance = projection["balance"]-- # Check for hegemony emergence- max_share = max(balance.distribution.values()) if balance.distribution else 0- if max_share > 0.6:- thresholds.append({- "year": year,- "type": "hegemony_emergence",- "dominant_power": max(balance.distribution, key=balance.distribution.get),- "power_share": max_share- })-- # Check for balance fragmentation- if balance.concentration_index < 0.15:- thresholds.append({- "year": year,- "type": "fragmentation",- "concentration_index": balance.concentration_index- })-- return thresholds-- def _generate_balance_scenarios(self, projections: List[Dict[str, Any]]) -> Dict[str, Any]:- """Generate scenarios based on power balance projections"""-- if not projections:- return {}-- final_projection = projections[-1]- final_balance = final_projection["balance"]-- # Determine scenario type- max_share = max(final_balance.distribution.values()) if final_balance.distribution else 0-- if max_share > 0.5:- scenario_type = "emerging_hegemon"- elif final_balance.concentration_index > 0.3:- scenario_type = "bipolar_competition"- elif final_balance.concentration_index < 0.15:- scenario_type = "multipolar_fragmentation"- else:- scenario_type = "balanced_multipolar"-- return {- "scenario_type": scenario_type,- "dominant_features": self._describe_scenario_features(scenario_type, final_balance),- "key_players": self._identify_key_players(final_balance),- "strategic_implications": self._analyze_scenario_implications(scenario_type)- }-- def _describe_scenario_features(self, scenario_type: str, balance: PowerBalance) -> List[str]:- """Describe key features of a power balance scenario"""-- feature_map = {- "emerging_hegemon": [- "Single dominant power emerging",- "High concentration of power",- "Potential regional hegemony",- "Increased instability risks"- ],- "bipolar_competition": [- "Two dominant powers competing",- "Clear alliance structures forming",- "Stable but tense competition",- "Risk of proxy conflicts"- ],- "multipolar_fragmentation": [- "Multiple competing powers",- "Diffused power distribution",- "Complex alliance patterns",- "High negotiation complexity"- ],- "balanced_multipolar": [- "Multiple significant powers",- "Relatively balanced distribution",- "Stable competitive environment",- "Institution-based order"- ]- }-- return feature_map.get(scenario_type, ["Unknown scenario type"])-- def _identify_key_players(self, balance: PowerBalance) -> List[str]:- """Identify key players in the power balance"""-- # Top 3 powers by share- sorted_powers = sorted(- balance.distribution.items(),- key=lambda x: x[1],- reverse=True- )-- return [power for power, share in sorted_powers[:3]]-- def _analyze_scenario_implications(self, scenario_type: str) -> List[str]:- """Analyze strategic implications of power balance scenarios"""-- implication_map = {- "emerging_hegemon": [- "Need for containment strategies",- "Alliance strengthening imperative",- "Risk of regional destabilization",- "Balance of power restoration required"- ],- "bipolar_competition": [- "Strategic stability through mutual deterrence",- "Alliance management critical",- "Risk of escalation but manageable",- "Clear strategic choices available"- ],- "multipolar_fragmentation": [- "Complex diplomatic management required",- "Institution building essential",- "Risk of regional conflicts",- "Flexible strategic approaches needed"- ],- "balanced_multipolar": [- "Institutional cooperation viable",- "Collective security possible",- "Economic interdependence increases",- "Stable long-term prospects"- ]- }-- return implication_map.get(scenario_type, ["Strategic implications unknown"])-- def _generate_balance_recommendations(self, projections: List[Dict[str, Any]]) -> List[str]:- """Generate strategic recommendations based on balance projections"""-- if not projections:- return []-- recommendations = []- final_balance = projections[-1]["balance"]-- # Hegemony prevention recommendations- max_share = max(final_balance.distribution.values()) if final_balance.distribution else 0- if max_share > 0.5:- dominant_power = max(final_balance.distribution, key=final_balance.distribution.get)- recommendations.append(f"Develop containment strategies for {dominant_power.title()}")- recommendations.append("Strengthen alliance networks to balance emerging power")-- # Stability recommendations- if final_balance.stability_level in ["volatile", "competitive"]:- recommendations.append("Enhance diplomatic engagement to reduce tensions")- recommendations.append("Strengthen international institutions for conflict prevention")-- # Power transition recommendations- trends = self._analyze_projection_trends(projections)- if trends.get("dominant_trend") == "power_concentration":- recommendations.append("Monitor for power transitions and hegemonic ambitions")-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Initialize calculator- calculator = BalanceOfPowerCalculator()-- # Sample data for testing- military_data = {- "united_states": {"personnel": 1400000, "equipment_score": 95, "technology_level": 9, "projection_capability": 10, "nuclear_capability": True},- "china": {"personnel": 2000000, "equipment_score": 85, "technology_level": 8, "projection_capability": 6, "nuclear_capability": True},- "russia": {"personnel": 900000, "equipment_score": 70, "technology_level": 6, "projection_capability": 7, "nuclear_capability": True}- }-- economic_data = {- "united_states": {"gdp": 25000000000000, "growth_rate": 2.1, "trade_volume": 5000000000000, "tech_investment": 600000000000, "energy_independence": 0.8},- "china": {"gdp": 18000000000000, "growth_rate": 4.8, "trade_volume": 6000000000000, "tech_investment": 400000000000, "energy_independence": 0.7},- "russia": {"gdp": 2000000000000, "growth_rate": 1.5, "trade_volume": 800000000000, "tech_investment": 50000000000, "energy_independence": 0.9}- }-- diplomatic_data = {- "united_states": {"un_influence": 9, "alliance_strength": 9, "soft_power_index": 85, "mediation_role": 7, "institutional_power": 9},- "china": {"un_influence": 7, "alliance_strength": 6, "soft_power_index": 60, "mediation_role": 5, "institutional_power": 7},- "russia": {"un_influence": 5, "alliance_strength": 5, "soft_power_index": 40, "mediation_role": 6, "institutional_power": 6}- }-- # Calculate global power balance- balance = calculator.calculate_global_power_balance(military_data, economic_data, diplomatic_data)-- print("Global Power Balance Analysis:")- print(f"Power Distribution: {balance.distribution}")- print(f"Concentration Index: {balance.concentration_index:.3f}")- print(f"Stability Level: {balance.stability_level}")- print(f"Hegemony Risk: {balance.hegemony_risk}")-- # Show individual power metrics- for power, metrics in balance.powers.items():- print(f"\n{power.title()} Power Metrics:")- print(f" Military: {metrics.military_capability:.2f}")- print(f" Economic: {metrics.economic_strength:.2f}")- print(f" Overall: {metrics.overall_power:.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/primacy_calculations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/primacy_calculations.pydeleted file mode 100644index ea969be44..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/geostrategic_modules/primacy_calculations.py+++ /dev/null@@ -1,768 +0,0 @@-"""-PRIMACY ASSESSMENT MODULE-Geostrategic Module for Grand Chessboard Agents--This module implements Brzezinski's American primacy assessment framework,-evaluating the current state and prospects of American global leadership-and providing strategic recommendations for maintaining primacy.-"""--import logging-from typing import Dict, List, Any, Optional, Tuple-from dataclasses import dataclass-from enum import Enum-import math--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class PrimacyDimension(Enum):- """Dimensions of national power relevant to global primacy"""- MILITARY_SUPREMACY = "military_supremacy"- ECONOMIC_DOMINANCE = "economic_dominance"- TECHNOLOGICAL_SUPERIORITY = "technological_superiority"- DIPLOMATIC_LEADERSHIP = "diplomatic_leadership"- CULTURAL_INFLUENCE = "cultural_influence"- ALLIANCE_NETWORK = "alliance_network"--class PrimacyStatus(Enum):- """Current status of American primacy"""- DOMINANT = "dominant" # Clear global leadership across all dimensions- MAINTAINING = "maintaining" # Strong but facing challenges- CHALLENGED = "challenged" # Significant threats to primacy- DECLINING = "declining" # Clear erosion of primacy- COMPETITIVE = "competitive" # Multipolar competition--@dataclass-class PrimacyMetrics:- """Metrics for evaluating American primacy"""- current_status: PrimacyStatus- military_advantage: float # 0-1 scale- economic_leadership: float # 0-1 scale- technological_edge: float # 0-1 scale- diplomatic_influence: float # 0-1 scale- cultural_reach: float # 0-1 scale- alliance_strength: float # 0-1 scale- overall_primacy_score: float # Composite score--@dataclass-class PrimacyChallenge:- """Specific challenge to American primacy"""- challenge_type: str- severity: str # low, medium, high, critical- affected_dimensions: List[PrimacyDimension]- strategic_impact: str- recommended_responses: List[str]--class PrimacyAssessment:- """Comprehensive primacy assessment results"""- current_metrics: PrimacyMetrics- challenges: List[PrimacyChallenge]- opportunities: List[str]- primacy_trends: Dict[str, Any]- strategic_recommendations: List[str]- future_outlook: Dict[str, Any]--class PrimacyAssessment:- """- Evaluates American global primacy following Brzezinski's framework- for maintaining American leadership in the 21st century- """-- def __init__(self):- """Initialize the primacy assessment module"""- self.module_id = "primacy_calculations"-- # Dimension weights based on Brzezinski's primacy framework- self.dimension_weights = {- PrimacyDimension.MILITARY_SUPREMACY: 0.30,- PrimacyDimension.ECONOMIC_DOMINANCE: 0.25,- PrimacyDimension.TECHNOLOGICAL_SUPERIORITY: 0.20,- PrimacyDimension.DIPLOMATIC_LEADERSHIP: 0.15,- PrimacyDimension.ALLIANCE_NETWORK: 0.10- }-- # Primacy thresholds- self.dominant_threshold = 0.8- self.maintaining_threshold = 0.6- self.challenged_threshold = 0.4- self.competitive_threshold = 0.2-- # Key global regions for primacy assessment- self.critical_regions = [- "north_america", "europe", "east_asia", "middle_east",- "south_asia", "latin_america", "africa", "oceania"- ]-- # Primary challengers to American primacy- self.primary_challengers = ["china", "russia"]-- def evaluate_american_primacy(- self,- power_distribution: Dict[str, float],- alliance_structures: Dict[str, List[str]],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> PrimacyAssessment:- """- Evaluate current state and prospects of American global primacy-- Args:- power_distribution: Global power distribution by country- alliance_structures: Current alliance network structures- regional_dynamics: Regional geopolitical dynamics-- Returns:- Comprehensive primacy assessment with strategic recommendations- """- try:- logger.info("Evaluating American global primacy")-- # Calculate current primacy metrics- current_metrics = self._calculate_primacy_metrics(- power_distribution, alliance_structures, regional_dynamics- )-- # Identify primacy challenges- challenges = self._identify_primacy_challenges(- current_metrics, power_distribution, regional_dynamics- )-- # Identify primacy opportunities- opportunities = self._identify_primacy_opportunities(- current_metrics, alliance_structures, regional_dynamics- )-- # Analyze primacy trends- primacy_trends = self._analyze_primacy_trends(- current_metrics, regional_dynamics- )-- # Generate strategic recommendations- strategic_recommendations = self._generate_primacy_recommendations(- current_metrics, challenges, opportunities- )-- # Assess future outlook- future_outlook = self._assess_future_primacy_outlook(- current_metrics, challenges, opportunities, regional_dynamics- )-- return PrimacyAssessment(- current_metrics=current_metrics,- challenges=challenges,- opportunities=opportunities,- primacy_trends=primacy_trends,- strategic_recommendations=strategic_recommendations,- future_outlook=future_outlook- )-- except Exception as e:- logger.error(f"Error evaluating American primacy: {str(e)}")- raise-- def _calculate_primacy_metrics(- self,- power_distribution: Dict[str, float],- alliance_structures: Dict[str, List[str]],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> PrimacyMetrics:- """Calculate comprehensive primacy metrics for the United States"""-- # Extract American power share- us_power_share = power_distribution.get("united_states", 0)-- # Calculate military supremacy- military_advantage = self._assess_military_supremacy(power_distribution)-- # Calculate economic leadership- economic_leadership = self._assess_economic_leadership(power_distribution)-- # Calculate technological superiority- technological_edge = self._assess_technological_superiority(power_distribution)-- # Calculate diplomatic leadership- diplomatic_influence = self._assess_diplomatic_leadership(- alliance_structures, regional_dynamics- )-- # Calculate cultural influence- cultural_reach = self._assess_cultural_influence(power_distribution)-- # Calculate alliance network strength- alliance_strength = self._assess_alliance_network_strength(alliance_structures)-- # Calculate overall primacy score- overall_primacy_score = self._calculate_composite_primacy_score(- military_advantage, economic_leadership, technological_edge,- diplomatic_influence, alliance_strength- )-- # Determine primacy status- current_status = self._determine_primacy_status(overall_primacy_score)-- return PrimacyMetrics(- current_status=current_status,- military_advantage=military_advantage,- economic_leadership=economic_leadership,- technological_edge=technological_edge,- diplomatic_influence=diplomatic_influence,- cultural_reach=cultural_reach,- alliance_strength=alliance_strength,- overall_primacy_score=overall_primacy_score- )-- def _assess_military_supremacy(self, power_distribution: Dict[str, float]) -> float:- """Assess American military supremacy relative to other powers"""-- us_military_power = power_distribution.get("united_states_military", 0)- china_military_power = power_distribution.get("china_military", 0)- russia_military_power = power_distribution.get("russia_military", 0)-- # Compare to nearest competitors- max_competitor_power = max(china_military_power, russia_military_power)-- if max_competitor_power == 0:- return 1.0-- # Calculate military advantage ratio- military_ratio = us_military_power / max_competitor_power-- # Normalize to 0-1 scale (2:1 ratio = 1.0, 1:1 ratio = 0.5, 0.5:1 ratio = 0.0)- military_advantage = max(0.0, min(1.0, (military_ratio - 0.5) / 1.5))-- return military_advantage-- def _assess_economic_leadership(self, power_distribution: Dict[str, float]) -> float:- """Assess American economic leadership globally"""-- us_economic_power = power_distribution.get("united_states_economic", 0)- china_economic_power = power_distribution.get("china_economic", 0)- total_global_economy = sum(- power for key, power in power_distribution.items()- if "economic" in key- )-- if total_global_economy == 0:- return 0.0-- # Economic dominance measured by share of global economy and lead over China- global_share = us_economic_power / total_global_economy- china_gap = (us_economic_power - china_economic_power) / total_global_economy-- # Combine global dominance and competitive advantage- economic_leadership = (global_share * 0.6 + max(0, china_gap) * 0.4) * 2-- return min(1.0, max(0.0, economic_leadership))-- def _assess_technological_superiority(self, power_distribution: Dict[str, float]) -> float:- """Assess American technological superiority in critical domains"""-- us_tech_power = power_distribution.get("united_states_technology", 0)- china_tech_power = power_distribution.get("china_technology", 0)- total_global_tech = sum(- power for key, power in power_distribution.items()- if "technology" in key- )-- if total_global_tech == 0:- return 0.0-- # Technology dominance with emphasis on key domains- tech_share = us_tech_power / total_global_tech- tech_advantage = (us_tech_power - china_tech_power) / total_global_tech-- technological_edge = (tech_share * 0.7 + max(0, tech_advantage) * 0.3) * 2-- return min(1.0, max(0.0, technological_edge))-- def _assess_diplomatic_leadership(- self,- alliance_structures: Dict[str, List[str]],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> float:- """Assess American diplomatic leadership and alliance management"""-- # Evaluate alliance network strength- nato_strength = self._assess_nato_strength(alliance_structures)- asian_alliances = self._assess_asian_alliance_strength(alliance_structures)- global_partnerships = self._assess_global_partnerships(alliance_structures)-- # Evaluate diplomatic influence in regions- regional_influence = 0- for region in self.critical_regions:- region_data = regional_dynamics.get(region, {})- us_influence = region_data.get("us_influence", 0.5)- regional_influence += us_influence-- regional_influence /= len(self.critical_regions)-- # Combine alliance strength and regional influence- alliance_leadership = (nato_strength * 0.4 + asian_alliances * 0.3 +- global_partnerships * 0.2 + regional_influence * 0.1)-- return min(1.0, max(0.0, alliance_leadership))-- def _assess_cultural_influence(self, power_distribution: Dict[str, float]) -> float:- """Assess American cultural influence globally"""-- us_cultural_power = power_distribution.get("united_states_cultural", 0)- total_cultural_power = sum(- power for key, power in power_distribution.items()- if "cultural" in key- )-- if total_cultural_power == 0:- return 0.0-- # Cultural influence measured by global share- cultural_reach = us_cultural_power / total_cultural_power-- # Adjust for global reach and penetration- cultural_reach = min(1.0, cultural_reach * 1.5) # Boost for US cultural dominance-- return cultural_reach-- def _assess_alliance_network_strength(self, alliance_structures: Dict[str, List[str]]) -> float:- """Assess strength and effectiveness of American alliance network"""-- # Key alliance structures- nato_members = alliance_structures.get("nato", [])- asian_alliances = alliance_structures.get("asian_alliances", [])- middle_east_partners = alliance_structures.get("middle_east_partners", [])-- # Calculate alliance scores- nato_score = len([m for m in nato_members if m != "united_states"]) / 30 # 30 potential members- asian_score = len(asian_alliances) / 10 # 10 key Asian partners- me_score = len(middle_east_partners) / 8 # 8 key Middle East partners-- # Weight alliance importance- alliance_strength = (nato_score * 0.5 + asian_score * 0.3 + me_score * 0.2)-- return min(1.0, max(0.0, alliance_strength))-- def _calculate_composite_primacy_score(- self,- military: float,- economic: float,- technological: float,- diplomatic: float,- alliance: float- ) -> float:- """Calculate composite primacy score from individual dimensions"""-- return (- military * self.dimension_weights[PrimacyDimension.MILITARY_SUPREMACY] +- economic * self.dimension_weights[PrimacyDimension.ECONOMIC_DOMINANCE] +- technological * self.dimension_weights[PrimacyDimension.TECHNOLOGICAL_SUPERIORITY] +- diplomatic * self.dimension_weights[PrimacyDimension.DIPLOMATIC_LEADERSHIP] +- alliance * self.dimension_weights[PrimacyDimension.ALLIANCE_NETWORK]- )-- def _determine_primacy_status(self, primacy_score: float) -> PrimacyStatus:- """Determine current primacy status based on composite score"""-- if primacy_score >= self.dominant_threshold:- return PrimacyStatus.DOMINANT- elif primacy_score >= self.maintaining_threshold:- return PrimacyStatus.MAINTAINING- elif primacy_score >= self.challenged_threshold:- return PrimacyStatus.CHALLENGED- elif primacy_score >= self.competitive_threshold:- return PrimacyStatus.DECLINING- else:- return PrimacyStatus.COMPETITIVE-- def _identify_primacy_challenges(- self,- metrics: PrimacyMetrics,- power_distribution: Dict[str, float],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> List[PrimacyChallenge]:- """Identify specific challenges to American primacy"""-- challenges = []-- # Military challenges- if metrics.military_advantage < 0.7:- challenges.append(PrimacyChallenge(- challenge_type="military_competition",- severity=self._assess_severity(metrics.military_advantage),- affected_dimensions=[PrimacyDimension.MILITARY_SUPREMACY],- strategic_impact="Reduced military deterrence capability",- recommended_responses=[- "Increase defense R&D investment",- "Modernize nuclear arsenal",- "Strengthen alliance military capabilities"- ]- ))-- # Economic challenges- if metrics.economic_leadership < 0.6:- challenges.append(PrimacyChallenge(- challenge_type="economic_competition",- severity=self._assess_severity(metrics.economic_leadership),- affected_dimensions=[PrimacyDimension.ECONOMIC_DOMINANCE],- strategic_impact="Reduced global economic influence",- recommended_responses=[- "Enhance technological innovation",- "Improve trade competitiveness",- "Invest in critical infrastructure"- ]- ))-- # China rise as specific challenge- china_power = power_distribution.get("china", 0)- us_power = power_distribution.get("united_states", 0)- if china_power > us_power * 0.8:- challenges.append(PrimacyChallenge(- challenge_type="china_regional_hegemony",- severity="high" if china_power > us_power * 0.9 else "medium",- affected_dimensions=[- PrimacyDimension.MILITARY_SUPREMACY,- PrimacyDimension.ECONOMIC_DOMINANCE,- PrimacyDimension.DIPLOMATIC_LEADERSHIP- ],- strategic_impact="China approaching parity in key domains",- recommended_responses=[- "Strengthen Indo-Pacific alliances",- "Develop regional containment strategies",- "Maintain forward military presence"- ]- ))-- # Regional instability challenges- for region, data in regional_dynamics.items():- if data.get("conflict_risk") == "high":- challenges.append(PrimacyChallenge(- challenge_type=f"regional_instability_{region}",- severity="high",- affected_dimensions=[PrimacyDimension.DIPLOMATIC_LEADERSHIP],- strategic_impact=f"Regional instability in {region} challenging American influence",- recommended_responses=[- "Enhance diplomatic engagement",- "Provide security guarantees to partners",- "Support regional conflict resolution"- ]- ))-- return challenges-- def _identify_primacy_opportunities(- self,- metrics: PrimacyMetrics,- alliance_structures: Dict[str, List[str]],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> List[str]:- """Identify opportunities to strengthen American primacy"""-- opportunities = []-- # Technological leadership opportunities- if metrics.technological_edge > 0.7:- opportunities.append(- "Leverage technological superiority to expand global influence"- )-- # Alliance expansion opportunities- if metrics.alliance_strength < 0.7:- opportunities.append(- "Expand and strengthen alliance network to amplify American power"- )-- # Regional opportunities- for region, data in regional_dynamics.items():- if data.get("us_influence", 0.5) > 0.6:- opportunities.append(- f"Deepen strategic partnerships in {region} to consolidate influence"- )-- # Economic opportunities- if metrics.economic_leadership > 0.6:- opportunities.append(- "Use economic leverage to support diplomatic objectives and alliance commitments"- )-- return opportunities-- def _analyze_primacy_trends(- self,- metrics: PrimacyMetrics,- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> Dict[str, Any]:- """Analyze current trends affecting American primacy"""-- trends = {}-- # Analyze regional trends- gaining_regions = []- losing_regions = []-- for region, data in regional_dynamics.items():- us_influence = data.get("us_influence", 0.5)- historical_influence = data.get("historical_us_influence", 0.5)-- if us_influence > historical_influence * 1.1:- gaining_regions.append(region)- elif us_influence < historical_influence * 0.9:- losing_regions.append(region)-- trends["regional_influence"] = {- "gaining": gaining_regions,- "losing": losing_regions,- "overall_trend": "expanding" if len(gaining_regions) > len(losing_regions) else "contracting"- }-- # Analyze dimension-specific trends- dimension_trends = {}- if metrics.military_advantage < 0.6:- dimension_trends["military"] = "challenged"- if metrics.economic_leadership < 0.6:- dimension_trends["economic"] = "challenged"- if metrics.technological_edge > 0.7:- dimension_trends["technology"] = "dominant"- if metrics.diplomatic_influence > 0.6:- dimension_trends["diplomatic"] = "strong"-- trends["dimensional_trends"] = dimension_trends- trends["overall_trend"] = self._determine_overall_trend(dimension_trends)-- return trends-- def _generate_primacy_recommendations(- self,- metrics: PrimacyMetrics,- challenges: List[PrimacyChallenge],- opportunities: List[str]- ) -> List[str]:- """Generate strategic recommendations for maintaining American primacy"""-- recommendations = []-- # Address critical challenges- high_severity_challenges = [c for c in challenges if c.severity in ["high", "critical"]]- for challenge in high_severity_challenges:- recommendations.extend(challenge.recommended_responses[:2]) # Top 2 recommendations-- # Leverage opportunities- recommendations.extend(opportunities[:3]) # Top 3 opportunities-- # Dimension-specific recommendations- if metrics.military_advantage < 0.6:- recommendations.extend([- "Accelerate military modernization programs",- "Increase defense spending to maintain technological edge",- "Enhance force projection capabilities in critical regions"- ])-- if metrics.economic_leadership < 0.6:- recommendations.extend([- "Promote innovation and technological development",- "Address trade imbalances and competitiveness",- "Invest in infrastructure and human capital"- ])-- if metrics.alliance_strength < 0.6:- recommendations.extend([- "Deepen transatlantic partnerships",- "Expand Indo-Pacific alliance network",- "Strengthen burden-sharing arrangements with allies"- ])-- # Remove duplicates and limit to top recommendations- unique_recommendations = list(set(recommendations))- return unique_recommendations[:10] # Top 10 recommendations-- def _assess_future_primacy_outlook(- self,- metrics: PrimacyMetrics,- challenges: List[PrimacyChallenge],- opportunities: List[str],- regional_dynamics: Dict[str, Dict[str, Any]]- ) -> Dict[str, Any]:- """Assess future outlook for American primacy"""-- # Calculate challenge severity- challenge_score = sum(- {"low": 1, "medium": 2, "high": 3, "critical": 4}[c.severity]- for c in challenges- ) / max(1, len(challenges))-- # Calculate opportunity potential- opportunity_score = len(opportunities) / 10 # Normalized-- # Project future primacy score- current_score = metrics.overall_primacy_score- projected_change = (opportunity_score - challenge_score) * 0.1- future_score = max(0, min(1, current_score + projected_change))-- # Determine future status- future_status = self._determine_primacy_status(future_score)-- # Identify key factors influencing outlook- key_factors = []- if challenge_score > 2.5:- key_factors.append("High severity challenges require immediate attention")- if opportunity_score > 0.5:- key_factors.append("Significant opportunities for primacy enhancement")- if metrics.military_advantage > 0.7:- key_factors.append("Military superiority provides strategic foundation")- if metrics.economic_leadership < 0.5:- key_factors.append("Economic challenges threaten long-term primacy")-- return {- "projected_score": future_score,- "projected_status": future_status,- "outlook_assessment": self._assess_outlook_quality(challenge_score, opportunity_score),- "key_factors": key_factors,- "critical_priorities": self._identify_critical_priorities(challenges, metrics),- "time_horizon": "5-10 years"- }-- def _assess_severity(self, metric_value: float) -> str:- """Assess severity of challenge based on metric value"""- if metric_value < 0.3:- return "critical"- elif metric_value < 0.5:- return "high"- elif metric_value < 0.7:- return "medium"- else:- return "low"-- def _assess_nato_strength(self, alliance_structures: Dict[str, List[str]]) -> float:- """Assess NATO alliance strength and cohesion"""- nato_members = alliance_structures.get("nato", [])- return min(1.0, len(nato_members) / 32) # 32 potential NATO members-- def _assess_asian_alliance_strength(self, alliance_structures: Dict[str, List[str]]) -> float:- """Assess strength of Asian alliance network"""- asian_alliances = alliance_structures.get("asian_alliances", [])- key_partners = ["japan", "south_korea", "australia", "philippines"]- alliance_strength = sum(1 for partner in key_partners if partner in asian_alliances)- return min(1.0, alliance_strength / len(key_partners))-- def _assess_global_partnerships(self, alliance_structures: Dict[str, List[str]]) -> float:- """Assess global partnership network"""- partnerships = alliance_structures.get("global_partnerships", [])- return min(1.0, len(partnerships) / 20) # 20 key global partners-- def _determine_overall_trend(self, dimension_trends: Dict[str, str]) -> str:- """Determine overall primacy trend from dimension trends"""- challenged_count = sum(1 for trend in dimension_trends.values() if trend == "challenged")- strong_count = sum(1 for trend in dimension_trends.values() if trend in ["strong", "dominant"])-- if challenged_count > strong_count:- return "declining"- elif strong_count > challenged_count:- return "strengthening"- else:- return "stable"-- def _assess_outlook_quality(self, challenge_score: float, opportunity_score: float) -> str:- """Assess quality of future outlook"""- if challenge_score < 1.5 and opportunity_score > 0.6:- return "favorable"- elif challenge_score < 2.5 and opportunity_score > 0.3:- return "cautiously_optimistic"- elif challenge_score < 3.0:- return "challenged"- else:- return "concerning"-- def _identify_critical_priorities(- self,- challenges: List[PrimacyChallenge],- metrics: PrimacyMetrics- ) -> List[str]:- """Identify critical priorities for maintaining primacy"""-- priorities = []-- # Address most severe challenges- critical_challenges = [c for c in challenges if c.severity == "critical"]- if critical_challenges:- priorities.append("Immediate attention to critical primacy threats")-- # Strengthen weakest dimensions- dimension_scores = [- ("Military", metrics.military_advantage),- ("Economic", metrics.economic_leadership),- ("Technology", metrics.technological_edge),- ("Diplomatic", metrics.diplomatic_influence),- ("Alliance", metrics.alliance_strength)- ]-- weakest_dimension = min(dimension_scores, key=lambda x: x[1])- if weakest_dimension[1] < 0.5:- priorities.append(f"Strengthen {weakest_dimension[0]} capabilities")-- # Maintain strongest advantages- strongest_dimension = max(dimension_scores, key=lambda x: x[1])- if strongest_dimension[1] > 0.7:- priorities.append(f"Maintain {strongest_dimension[0]} superiority")-- return priorities--# Example usage and testing-if __name__ == "__main__":- # Initialize primacy assessor- assessor = PrimacyAssessment()-- # Sample data for testing- power_distribution = {- "united_states": 0.25,- "china": 0.18,- "russia": 0.08,- "united_states_military": 0.35,- "china_military": 0.20,- "russia_military": 0.15,- "united_states_economic": 0.24,- "china_economic": 0.19,- "russia_economic": 0.04,- "united_states_technology": 0.30,- "china_technology": 0.22,- "russia_technology": 0.08,- "united_states_cultural": 0.40,- "china_cultural": 0.15,- "russia_cultural": 0.05- }-- alliance_structures = {- "nato": ["united_states", "germany", "france", "united_kingdom", "italy", "canada", "poland"],- "asian_alliances": ["united_states", "japan", "south_korea", "australia"],- "global_partnerships": ["united_states", "india", "brazil", "south_africa", "israel"]- }-- regional_dynamics = {- "europe": {"us_influence": 0.7, "historical_us_influence": 0.8, "conflict_risk": "low"},- "east_asia": {"us_influence": 0.6, "historical_us_influence": 0.7, "conflict_risk": "medium"},- "middle_east": {"us_influence": 0.5, "historical_us_influence": 0.6, "conflict_risk": "high"},- "europe": {"us_influence": 0.7, "historical_us_influence": 0.8, "conflict_risk": "low"},- "north_america": {"us_influence": 0.9, "historical_us_influence": 0.9, "conflict_risk": "low"}- }-- # Evaluate American primacy- assessment = assessor.evaluate_american_primacy(- power_distribution, alliance_structures, regional_dynamics- )-- print("American Primacy Assessment:")- print(f"Current Status: {assessment.current_metrics.current_status}")- print(f"Overall Primacy Score: {assessment.current_metrics.overall_primacy_score:.2f}")- print(f"Military Advantage: {assessment.current_metrics.military_advantage:.2f}")- print(f"Economic Leadership: {assessment.current_metrics.economic_leadership:.2f}")- print(f"Technological Edge: {assessment.current_metrics.technological_edge:.2f}")- print(f"Diplomatic Influence: {assessment.current_metrics.diplomatic_influence:.2f}")- print(f"Alliance Strength: {assessment.current_metrics.alliance_strength:.2f}")-- print(f"\nChallenges Identified: {len(assessment.challenges)}")- for challenge in assessment.challenges:- print(f" - {challenge.challenge_type}: {challenge.severity}")-- print(f"\nStrategic Opportunities: {len(assessment.opportunities)}")- for opportunity in assessment.opportunities:- print(f" - {opportunity}")-- print(f"\nFuture Outlook: {assessment.future_outlook['projected_status']}")- print(f"Projected Score: {assessment.future_outlook['projected_score']:.2f}")\ No newline at end of filediff --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.pynew file mode 100644index 000000000..e6d771f05--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/american_primacy_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..e6d771f05--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/eurasian_balkans_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..e6d771f05--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/heartland_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..e6d771f05--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/pivots_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..e6d771f05--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/strategy_agents/players_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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/test_agents/comprehensive_test_framework.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/test_agents/comprehensive_test_framework.pydeleted file mode 100644index ba8612ea4..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/GrandChessboardAgents/test_agents/comprehensive_test_framework.py+++ /dev/null@@ -1,950 +0,0 @@-"""-COMPREHENSIVE TEST FRAMEWORK-Complete Testing System for Grand Chessboard Agents--This module provides comprehensive testing capabilities for all Grand Chessboard agents,-including individual agent testing, inter-agent communication testing,-framework compliance validation, and integration testing.-"""--import logging-import asyncio-import json-from typing import Dict, List, Any, Optional, Callable-from dataclasses import dataclass, field-from datetime import datetime-import time-import unittest-from enum import Enum--# Configure logging-logging.basicConfig(level=logging.INFO)-logger = logging.getLogger(__name__)--class TestType(Enum):- """Types of tests for Grand Chessboard agents"""- UNIT_TEST = "unit_test" # Individual component testing- INTEGRATION_TEST = "integration_test" # Agent integration testing- FRAMEWORK_COMPLIANCE = "framework_compliance" # Brzezinski framework compliance- INTER_AGENT_COMMUNICATION = "inter_agent_communication" # Communication between agents- COORDINATION_TEST = "coordination_test" # Multi-agent coordination- PERFORMANCE_TEST = "performance_test" # Performance and scalability- END_TO_END_TEST = "end_to_end_test" # Complete workflow testing--class TestResult(Enum):- """Test result status"""- PASSED = "passed"- FAILED = "failed"- SKIPPED = "skipped"- ERROR = "error"- TIMEOUT = "timeout"--@dataclass-class TestScenario:- """Test scenario definition"""- id: str- name: str- description: str- test_type: TestType- test_data: Dict[str, Any]- expected_results: Dict[str, Any]- agents_involved: List[str]- timeout: int = 300 # 5 minutes default- priority: str = "normal" # high, normal, low--@dataclass-class TestExecution:- """Result of test execution"""- scenario_id: str- agent_id: Optional[str]- test_type: TestType- start_time: datetime- end_time: Optional[datetime]- result: TestResult- actual_results: Optional[Dict[str, Any]]- expected_results: Dict[str, Any]- errors: List[str] = field(default_factory=list)- performance_metrics: Dict[str, float] = field(default_factory=dict)- compliance_score: Optional[float] = None--@dataclass-class TestSuite:- """Collection of test scenarios for specific testing"""- name: str- description: str- scenarios: List[TestScenario]- setup_functions: Dict[str, Callable] = field(default_factory=dict)- teardown_functions: Dict[str, Callable] = field(default_factory=dict)- test_data_generators: Dict[str, Callable] = field(default_factory=dict)--class GrandChessboardTestFramework:- """- Comprehensive testing framework for Grand Chessboard agents-- Features:- - Individual agent testing with framework compliance validation- - Inter-agent communication and coordination testing- - Brzezinski framework compliance scoring- - Performance benchmarking and scalability testing- - Test data generation and management- - Automated test execution and reporting- - Integration testing with real LLM providers- """-- def __init__(self):- """Initialize the comprehensive test framework"""- self.framework_id = "comprehensive_test_framework"-- # Test execution tracking- self.test_executions = []- self.test_suites = {}-- # Mock data and providers- self.mock_data_providers = {}- self.llm_providers = {}-- # Test configuration- self.default_timeout = 300 # 5 minutes- self.parallel_execution = True- self.max_parallel_tests = 5-- # Initialize test suites- self._initialize_test_suites()-- def _initialize_test_suites(self) -> None:- """Initialize all test suites for Grand Chessboard agents"""-- # Individual Agent Test Suite- self.test_suites["individual_agents"] = TestSuite(- name="Individual Agent Tests",- description="Test each Grand Chessboard agent independently",- scenarios=self._create_individual_agent_scenarios()- )-- # Framework Compliance Test Suite- self.test_suites["framework_compliance"] = TestSuite(- name="Brzezinski Framework Compliance",- description="Validate compliance with Brzezinski's theoretical framework",- scenarios=self._create_framework_compliance_scenarios()- )-- # Inter-Agent Communication Test Suite- self.test_suites["inter_agent_communication"] = TestSuite(- name="Inter-Agent Communication Tests",- description="Test communication and coordination between agents",- scenarios=self._create_communication_test_scenarios()- )-- # Integration Test Suite- self.test_suites["integration"] = TestSuite(- name="Integration Tests",- description="Test complete workflow and data flow between components",- scenarios=self._create_integration_test_scenarios()- )-- # Performance Test Suite- self.test_suites["performance"] = TestSuite(- name="Performance Tests",- description="Test performance, scalability, and resource usage",- scenarios=self._create_performance_test_scenarios()- )-- # End-to-End Test Suite- self.test_suites["end_to_end"] = TestSuite(- name="End-to-End Workflow Tests",- description="Test complete Grand Chessboard analysis workflows",- scenarios=self._create_end_to_end_scenarios()- )-- def run_test_suite(- self,- suite_name: str,- parallel: bool = None,- include_compliance: bool = True- ) -> Dict[str, Any]:- """- Run a complete test suite-- Args:- suite_name: Name of test suite to run- parallel: Whether to run tests in parallel (default from framework config)- include_compliance: Whether to include framework compliance tests-- Returns:- Comprehensive test results and analysis- """- try:- if suite_name not in self.test_suites:- raise ValueError(f"Test suite '{suite_name}' not found")-- logger.info(f"Running test suite: {suite_name}")- start_time = datetime.now()-- test_suite = self.test_suites[suite_name]- execution_results = []-- # Configure parallel execution- use_parallel = parallel if parallel is not None else self.parallel_execution-- if use_parallel:- execution_results = self._run_tests_parallel(test_suite.scenarios)- else:- execution_results = self._run_tests_sequential(test_suite.scenarios)-- end_time = datetime.now()- total_duration = (end_time - start_time).total_seconds()-- # Run framework compliance tests if requested- compliance_results = None- if include_compliance and suite_name != "framework_compliance":- compliance_results = self._run_framework_compliance_tests(- [scenario.id for scenario in test_suite.scenarios]- )-- # Analyze results- analysis = self._analyze_test_results(execution_results, compliance_results)-- return {- "suite_name": suite_name,- "total_scenarios": len(test_suite.scenarios),- "executed_tests": len(execution_results),- "passed_tests": len([e for e in execution_results if e.result == TestResult.PASSED]),- "failed_tests": len([e for e in execution_results if e.result == TestResult.FAILED]),- "total_duration": total_duration,- "execution_results": execution_results,- "compliance_results": compliance_results,- "analysis": analysis,- "summary": self._generate_test_summary(execution_results, analysis)- }-- except Exception as e:- logger.error(f"Error running test suite {suite_name}: {str(e)}")- return {- "suite_name": suite_name,- "error": str(e),- "total_scenarios": 0,- "executed_tests": 0,- "passed_tests": 0,- "failed_tests": 0,- "total_duration": 0,- "execution_results": [],- "compliance_results": None,- "analysis": None,- "summary": None- }-- def run_framework_compliance_tests(self, agent_ids: List[str]) -> Dict[str, Any]:- """- Run Brzezinski framework compliance tests for specified agents-- Args:- agent_ids: List of agent IDs to test for compliance-- Returns:- Compliance test results and scores- """- try:- logger.info("Running framework compliance tests")- compliance_suite = self.test_suites["framework_compliance"]-- # Filter scenarios for specific agents- relevant_scenarios = [- scenario for scenario in compliance_suite.scenarios- if any(agent_id in scenario.agents_involved for agent_id in agent_ids)- ]-- # Run compliance tests- execution_results = self._run_tests_sequential(relevant_scenarios)-- # Calculate compliance scores- compliance_scores = {}- for agent_id in agent_ids:- agent_results = [- result for result in execution_results- if result.agent_id == agent_id- ]- if agent_results:- scores = [- result.compliance_score for result in agent_results- if result.compliance_score is not None- ]- if scores:- compliance_scores[agent_id] = sum(scores) / len(scores)- else:- compliance_scores[agent_id] = 0.0- else:- compliance_scores[agent_id] = None-- # Analyze compliance results- analysis = self._analyze_compliance_results(execution_results, compliance_scores)-- return {- "suite_name": "framework_compliance",- "tested_agents": agent_ids,- "total_scenarios": len(relevant_scenarios),- "executed_tests": len(execution_results),- "passed_tests": len([e for e in execution_results if e.result == TestResult.PASSED]),- "failed_tests": len([e for e in execution_results if e.result == TestResult.FAILED]),- "compliance_scores": compliance_scores,- "execution_results": execution_results,- "analysis": analysis,- "compliance_summary": self._generate_compliance_summary(compliance_scores, analysis)- }-- except Exception as e:- logger.error(f"Error running framework compliance tests: {str(e)}")- return {- "error": str(e),- "tested_agents": agent_ids,- "total_scenarios": 0,- "executed_tests": 0,- "passed_tests": 0,- "failed_tests": 0,- "compliance_scores": {},- "execution_results": [],- "analysis": None,- "compliance_summary": None- }-- def run_performance_benchmarks(self, agent_ids: List[str]) -> Dict[str, Any]:- """- Run performance benchmarks for specified agents-- Args:- agent_ids: List of agent IDs to benchmark-- Returns:- Performance benchmark results- """- try:- logger.info(f"Running performance benchmarks for agents: {agent_ids}")- performance_suite = self.test_suites["performance"]-- # Filter performance scenarios for specified agents- relevant_scenarios = [- scenario for scenario in performance_suite.scenarios- if any(agent_id in scenario.agents_involved for agent_id in agent_ids)- ]-- # Run performance tests- execution_results = self._run_tests_sequential(relevant_scenarios)-- # Analyze performance metrics- performance_analysis = self._analyze_performance_results(execution_results)-- return {- "suite_name": "performance",- "tested_agents": agent_ids,- "total_scenarios": len(relevant_scenarios),- "executed_tests": len(execution_results),- "execution_results": execution_results,- "performance_analysis": performance_analysis,- "benchmark_summary": self._generate_performance_summary(performance_analysis)- }-- except Exception as e:- logger.error(f"Error running performance benchmarks: {str(e)}")- return {- "error": str(e),- "tested_agents": agent_ids,- "total_scenarios": 0,- "executed_tests": 0,- "execution_results": [],- "performance_analysis": None,- "benchmark_summary": None- }-- def _create_individual_agent_scenarios(self) -> List[TestScenario]:- """Create test scenarios for individual agent testing"""-- scenarios = []-- # Master Agent Tests- scenarios.extend([- TestScenario(- id="master_agent_basic_analysis",- name="Master Agent Basic Analysis",- description="Test master agent's core analysis capabilities",- test_type=TestType.UNIT_TEST,- test_data=self._generate_master_agent_test_data(),- expected_results={- "primacy_assessment": {"status": "calculated"},- "hegemony_analysis": {"status": "analyzed"},- "strategic_recommendations": {"count": ">0"}- },- agents_involved=["eurasian_chessboard_master"]- ),- TestScenario(- id="master_agent_data_integration",- name="Master Agent Data Integration",- description="Test master agent's ability to integrate multiple data sources",- test_type=TestType.INTEGRATION_TEST,- test_data=self._generate_comprehensive_test_data(),- expected_results={- "data_integration": {"status": "successful"},- "coherence_score": {"value": ">0.7"}- },- agents_involved=["eurasian_chessboard_master"]- )- ])-- # European Bridgehead Agent Tests- scenarios.extend([- TestScenario(- id="european_integration_analysis",- name="European Integration Analysis",- description="Test European agent's integration assessment",- test_type=TestType.UNIT_TEST,- test_data=self._generate_european_test_data(),- expected_results={- "integration_status": {"status": "determined"},- "nato_effectiveness": {"status": "analyzed"}- },- agents_involved=["democratic_bridgehead"]- )- ])-- # Black Hole Agent Tests- scenarios.extend([- TestScenario(- id="russian_trajectory_analysis",- name="Russian Trajectory Analysis",- description="Test Black Hole agent's Russian trajectory assessment",- test_type=TestType.UNIT_TEST,- test_data=self._generate_russian_test_data(),- expected_results={- "trajectory": {"status": "determined"},- "containment_needs": {"status": "assessed"}- },- agents_involved=["black_hole"]- )- ])-- # Eurasian Balkans Agent Tests- scenarios.extend([- TestScenario(- id="central_asia_competition",- name="Central Asia Competition Analysis",- description="Test Balkans agent's competition assessment",- test_type=TestType.UNIT_TEST,- test_data=self._generate_central_asia_test_data(),- expected_results={- "stability_level": {"status": "assessed"},- "power_distribution": {"status": "calculated"}- },- agents_involved=["eurasian_balkans"]- )- ])-- # Far Eastern Anchor Agent Tests- scenarios.extend([- TestScenario(- id="east_asia_balance",- name="East Asia Balance Analysis",- description="Test Far Eastern agent's balance assessment",- test_type=TestType.UNIT_TEST,- test_data=self._generate_east_asia_test_data(),- expected_results={- "balance_level": {"status": "determined"},- "china_trajectory": {"status": "analyzed"}- },- agents_involved=["far_eastern_anchor"]- )- ])-- return scenarios-- def _create_framework_compliance_scenarios(self) -> List[TestScenario]:- """Create test scenarios for Brzezinski framework compliance"""-- scenarios = []-- # Core Framework Compliance Tests- scenarios.extend([- TestScenario(- id="eurasian_primacy_focus",- name="Eurasian Primacy Focus",- description="Test agent focus on Eurasian competition dynamics",- test_type=TestType.FRAMEWORK_COMPLIANCE,- test_data=self._generate_framework_test_data(),- expected_results={- "eurasian_focus": {"compliance_score": ">0.8"},- "brzezinski_concepts": {"recognition_rate": ">0.7"}- },- agents_involved=["eurasian_chessboard_master", "democratic_bridgehead",- "black_hole", "eurasian_balkans", "far_eastern_anchor"]- ),- TestScenario(- id="american_primacy_maintenance",- name="American Primacy Maintenance",- description="Test focus on American global leadership",- test_type=TestType.FRAMEWORK_COMPLIANCE,- test_data=self._generate_framework_test_data(),- expected_results={- "american_primacy": {"compliance_score": ">0.8"},- "balance_management": {"assessment": "present"}- },- agents_involved=["eurasian_chessboard_master", "american_hegemony"]- )- ])-- return scenarios-- def _create_communication_test_scenarios(self) -> List[TestScenario]:- """Create test scenarios for inter-agent communication"""-- scenarios = []-- # Message Passing Tests- scenarios.extend([- TestScenario(- id="insight_sharing_test",- name="Agent Insight Sharing",- description="Test agents sharing insights with each other",- test_type=TestType.INTER_AGENT_COMMUNICATION,- test_data=self._generate_communication_test_data(),- expected_results={- "message_delivery": {"success_rate": "1.0"},- "insight_integration": {"status": "successful"}- },- agents_involved=["democratic_bridgehead", "black_hole", "eurasian_balkans"]- ),- TestScenario(- id="coordination_request_test",- name="Multi-Agent Coordination",- description="Test coordination requests between agents",- test_type=TestType.COORDINATION_TEST,- test_data=self._generate_coordination_test_data(),- expected_results={- "coordination_success": {"status": "completed"},- "result_synthesis": {"status": "successful"}- },- agents_involved=["eurasian_chessboard_master", "democratic_bridgehead", "far_eastern_anchor"]- )- ])-- return scenarios-- def _create_integration_test_scenarios(self) -> List[TestScenario]:- """Create end-to-end integration test scenarios"""-- scenarios = []-- # Complete Analysis Workflow Tests- scenarios.extend([- TestScenario(- id="complete_chessboard_analysis",- name="Complete Chessboard Analysis",- description="Test complete Grand Chessboard analysis workflow",- test_type=TestType.END_TO_END_TEST,- test_data=self._generate_integration_test_data(),- expected_results={- "workflow_completion": {"status": "successful"},- "analysis_coherence": {"score": ">0.8"}- },- agents_involved=["eurasian_chessboard_master", "democratic_bridgehead",- "black_hole", "eurasian_balkans", "far_eastern_anchor"]- )- ])-- return scenarios-- def _create_performance_test_scenarios(self) -> List[TestScenario]:- """Create performance testing scenarios"""-- scenarios = []-- # Load and Performance Tests- scenarios.extend([- TestScenario(- id="large_data_processing",- name="Large Data Processing",- description="Test agent performance with large datasets",- test_type=TestType.PERFORMANCE_TEST,- test_data=self._generate_large_test_data(),- expected_results={- "processing_time": {"max_seconds": 60},- "memory_usage": {"max_mb": 512}- },- agents_involved=["eurasian_chessboard_master"]- ),- TestScenario(- id="concurrent_analysis",- name="Concurrent Analysis",- description="Test agent performance under concurrent requests",- test_type=TestType.PERFORMANCE_TEST,- test_data=self._generate_concurrent_test_data(),- expected_results={- "response_time": {"max_ms": 5000},- "concurrent_handling": {"success_rate": "1.0"}- },- agents_involved=["democratic_bridgehead", "black_hole", "eurasian_balkans"]- )- ])-- return scenarios-- def _create_end_to_end_scenarios(self) -> List[TestScenario]:- """Create end-to-end workflow test scenarios"""-- scenarios = []-- # Strategic Analysis Workflow- scenarios.extend([- TestScenario(- id="strategic_assessment_workflow",- name="Strategic Assessment Workflow",- description="Test complete strategic assessment workflow",- test_type=TestType.END_TO_END_TEST,- test_data=self._generate_strategic_workflow_data(),- expected_results={- "workflow_success": {"status": "completed"},- "strategic_output": {"completeness": ">0.9"}- },- agents_involved=["eurasian_chessboard_master", "all_agents"]- )- ])-- return scenarios-- def _run_tests_sequential(self, scenarios: List[TestScenario]) -> List[TestExecution]:- """Run test scenarios sequentially"""- execution_results = []-- for scenario in scenarios:- execution = self._execute_single_test(scenario)- execution_results.append(execution)-- return execution_results-- def _run_tests_parallel(self, scenarios: List[TestScenario]) -> List[TestExecution]:- """Run test scenarios in parallel"""- execution_results = []-- # Split scenarios into batches- batch_size = min(self.max_parallel_tests, len(scenarios))- batches = [scenarios[i:i + batch_size] for i in range(0, len(scenarios), batch_size)]-- for batch in batches:- # Execute batch in parallel- batch_results = []- with ThreadPoolExecutor(max_workers=batch_size) as executor:- futures = [- executor.submit(self._execute_single_test, scenario)- for scenario in batch- ]-- for future in as_completed(futures):- try:- result = future.result(timeout=scenario.timeout)- batch_results.append(result)- except TimeoutError:- # Create timeout result- timeout_result = TestExecution(- scenario_id=scenario.id,- agent_id=None,- test_type=scenario.test_type,- start_time=result.start_time,- end_time=datetime.now(),- result=TestResult.TIMEOUT,- actual_results=None,- expected_results=scenario.expected_results,- errors=["Test execution timed out"]- )- batch_results.append(timeout_result)- except Exception as e:- # Create error result- error_result = TestExecution(- scenario_id=scenario.id,- agent_id=None,- test_type=scenario.test_type,- start_time=datetime.now(),- end_time=datetime.now(),- result=TestResult.ERROR,- actual_results=None,- expected_results=scenario.expected_results,- errors=[str(e)]- )- batch_results.append(error_result)-- execution_results.extend(batch_results)-- return execution_results-- def _execute_single_test(self, scenario: TestScenario) -> TestExecution:- """Execute a single test scenario"""- start_time = datetime.now()-- try:- # Import and execute the appropriate agent- agent_result = self._execute_agent_test(scenario)-- # Compare with expected results- test_result = self._compare_results(agent_result, scenario.expected_results)-- end_time = datetime.now()- execution_time = (end_time - start_time).total_seconds()-- return TestExecution(- scenario_id=scenario.id,- agent_id=scenario.agents_involved[0] if scenario.agents_involved else None,- test_type=scenario.test_type,- start_time=start_time,- end_time=end_time,- result=test_result,- actual_results=agent_result,- expected_results=scenario.expected_results,- performance_metrics={"execution_time": execution_time},- compliance_score=self._calculate_compliance_score(agent_result, scenario)- )-- except Exception as e:- return TestExecution(- scenario_id=scenario.id,- agent_id=scenario.agents_involved[0] if scenario.agents_involved else None,- test_type=scenario.test_type,- start_time=start_time,- end_time=datetime.now(),- result=TestResult.ERROR,- actual_results=None,- expected_results=scenario.expected_results,- errors=[str(e)],- performance_metrics={},- compliance_score=0.0- )-- # Test data generation methods- def _generate_master_agent_test_data(self) -> Dict[str, Any]:- """Generate test data for master agent"""- return {- "current_events": [- {"id": "1", "type": "geopolitical", "description": "China expands military presence"},- {"id": "2", "type": "economic", "description": "NATO announces new initiatives"}- ],- "strategic_moves_by_powers": {- "military_moves": {"china": "expansion", "russia": "containment"},- "economic_moves": {"us": "sanctions", "eu": "cooperation"}- },- "military_deployments": [- {"location": "pacific", "force": "carrier_group"},- {"location": "europe", "force": "enhanced_forward_presence"}- ],- "economic_indicators": {- "us_growth": 2.1, "china_growth": 4.8, "eu_growth": 1.4- }- }-- def _generate_framework_test_data(self) -> Dict[str, Any]:- """Generate test data for framework compliance"""- return {- "test_scenarios": [- {"focus": "eurasian_competition", "complexity": "high"},- {"focus": "american_primacy", "complexity": "medium"},- {"focus": "balance_management", "complexity": "high"}- ],- "brzezinski_concepts": [- "eurasian_chessboard", "geostrategic_players", "geopolitical_pivots",- "democratic_bridgehead", "black_hole", "eurasian_balkans",- "far_eastern_anchor", "american_hegemony"- ]- }-- # Additional test data generation methods...- def _generate_european_test_data(self) -> Dict[str, Any]:- """Generate test data for European agent"""- return {- "european_events": [- {"id": "1", "type": "political", "description": "EU announces defense integration"},- {"id": "2", "type": "military", "description": "NATO expansion discussions"}- ],- "nato_developments": [- {"id": "1", "type": "expansion", "status": "in_progress"}- ],- "eu_integration_data": {- "policy_harmonization": 0.7,- "economic_integration": 0.8- }- }-- def _generate_russian_test_data(self) -> Dict[str, Any]:- """Generate test data for Black Hole agent"""- return {- "russian_events": [- {"id": "1", "type": "military", "description": "Russia military modernization"},- {"id": "2", "type": "political", "description": "Near abroad policy statements"}- ],- "russian_capabilities": {- "military_capability": 0.7,- "economic_strength": 0.5,- "internal_stability": 0.6- }- }-- # Additional test data generators would be implemented here...-- def _compare_results(self, actual: Dict[str, Any], expected: Dict[str, Any]) -> TestResult:- """Compare actual test results with expected results"""- # Simplified comparison logic- try:- for key, expected_value in expected.items():- if key in actual:- # Simple validation - could be enhanced- if isinstance(expected_value, dict):- if "status" in expected_value:- expected_status = expected_value["status"]- actual_status = actual[key].get("status", "")- if expected_status == actual_status:- continue- else:- return TestResult.FAILED- elif actual[key] == expected_value:- continue- else:- return TestResult.FAILED- else:- return TestResult.FAILED-- return TestResult.PASSED-- except Exception as e:- logger.error(f"Error comparing results: {str(e)}")- return TestResult.ERROR-- def _calculate_compliance_score(self, result: Dict[str, Any], scenario: TestScenario) -> float:- """Calculate compliance score for framework compliance tests"""- if scenario.test_type != TestType.FRAMEWORK_COMPLIANCE:- return None-- # Simplified compliance scoring- try:- compliance_factors = []-- # Check for Brzezinski concept recognition- if "brzezinski_concepts" in result:- concepts = result["brzezinski_concepts"]- recognized = sum(1 for concept in concepts if concept.get("recognized", False))- compliance_factors.append(recognized / len(concepts))-- # Check for Eurasian focus- if "eurasian_focus" in result:- focus_score = result["eurasian_focus"].get("score", 0)- compliance_factors.append(focus_score)-- # Check for American primacy focus- if "american_primacy" in result:- primacy_score = result["american_primacy"].get("score", 0)- compliance_factors.append(primacy_score)-- if compliance_factors:- return sum(compliance_factors) / len(compliance_factors)- else:- return 0.5 # Default score-- except Exception as e:- logger.error(f"Error calculating compliance score: {str(e)}")- return 0.0-- # Analysis methods- def _analyze_test_results(self, executions: List[TestExecution], compliance_results: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:- """Analyze test execution results"""- passed_count = len([e for e in executions if e.result == TestResult.PASSED])- failed_count = len([e for e in executions if e.result == TestResult.FAILED])- error_count = len([e for e in executions if e.result == TestResult.ERROR])-- # Calculate average compliance scores- compliance_scores = [e.compliance_score for e in executions if e.compliance_score is not None]- avg_compliance = sum(compliance_scores) / len(compliance_scores) if compliance_scores else 0-- # Performance analysis- execution_times = [e.performance_metrics.get("execution_time", 0) for e in executions]- avg_execution_time = sum(execution_times) / len(execution_times) if execution_times else 0-- return {- "total_tests": len(executions),- "passed_tests": passed_count,- "failed_tests": failed_count,- "error_tests": error_count,- "success_rate": passed_count / len(executions) if executions else 0,- "average_compliance": avg_compliance,- "average_execution_time": avg_execution_time,- "performance_analysis": self._analyze_performance_metrics(executions),- "test_coverage": self._calculate_test_coverage(executions)- }-- def _generate_test_summary(self, executions: List[TestExecution], analysis: Dict[str, Any]) -> Dict[str, Any]:- """Generate comprehensive test summary"""- return {- "test_summary": {- "total_executed": len(executions),- "success_rate": analysis.get("success_rate", 0),- "framework_compliance": analysis.get("average_compliance", 0),- "performance_rating": self._calculate_performance_rating(analysis.get("average_execution_time", 0))- },- "recommendations": self._generate_test_recommendations(executions, analysis),- "next_steps": self._generate_next_steps(executions, analysis)- }--# Main execution function-def run_grand_chessboard_tests(- test_suites: Optional[List[str]] = None,- parallel_execution: bool = True,- include_compliance: bool = True-) -> Dict[str, Any]:- """- Main function to run Grand Chessboard agent tests-- Args:- test_suites: List of test suite names to run (None for all)- parallel_execution: Whether to run tests in parallel- include_compliance: Whether to include framework compliance tests-- Returns:- Comprehensive test results and analysis- """- framework = GrandChessboardTestFramework()-- # Determine which test suites to run- if test_suites is None:- test_suites = ["individual_agents", "framework_compliance", "inter_agent_communication",- "integration", "performance", "end_to_end"]- else:- test_suites = test_suites-- # Run specified test suites- results = {}- for suite_name in test_suites:- if suite_name in framework.test_suites:- results[suite_name] = framework.run_test_suite(- suite_name, parallel_execution, include_compliance- )-- return {- "test_execution_summary": {- "total_suites_run": len(results),- "suite_results": results,- "overall_success_rate": sum(- suite_result.get("success_rate", 0) for suite_result in results.values()- ) / len(results) if results else 0- },- "detailed_results": results- }--if __name__ == "__main__":- # Example usage- results = run_grand_chessboard_tests(- test_suites=["individual_agents", "framework_compliance"],- parallel_execution=True,- include_compliance=True- )-- print("Grand Chessboard Agent Test Results:")- print(f"Total Test Suites: {len(results['detailed_results'])}")- print(f"Overall Success Rate: {results['test_execution_summary']['overall_success_rate']:.2%}")-- for suite_name, suite_results in results['detailed_results'].items():- print(f"\n{suite_name} Results:")- print(f" Passed: {suite_results.get('passed_tests', 0)}")- print(f" Failed: {suite_results.get('failed_tests', 0)}")- if suite_results.get('compliance_scores'):- avg_compliance = sum(suite_results['compliance_scores'].values()) / len(suite_results['compliance_scores'])- print(f" Avg Compliance: {avg_compliance:.2%}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/geographic_constraints.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/geographic_constraints.pydeleted file mode 100644index e4b298874..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/geographic_constraints.py+++ /dev/null@@ -1,312 +0,0 @@-"""-Geographic Constraints Analysis Module-Shared tools for analyzing how geography constrains geopolitical behavior-Based on Tim Marshall's geographic determinism framework-"""--from typing import Dict, List, Any, Optional-import json-from datetime import datetime--def analyze_physical_constraints(region: str, event_data: Dict) -> Dict[str, Any]:- """- Analyze physical geographic constraints that determine geopolitical behavior-- Physical constraints include:- - Topography (mountains, plains, deserts)- - Climate (arctic, temperate, tropical, arid)- - Water access (oceans, seas, rivers, lakes)- - Natural resources location- - Population distribution patterns- """-- constraint_frameworks = {- "topographic_constraints": {- "mountains": {- "constraint": "barriers_to_movement_and_trade",- "security_aspect": "natural_defense_borders",- "economic_aspect": "transportation_difficulties",- "political_aspect": "cultural_isolation_development"- },- "plains": {- "constraint": "easy_invasion_routes",- "security_aspect": "vulnerability_to_attack",- "economic_aspect": "agricultural_advantages",- "political_aspect": "power_projection_capability"- },- "deserts": {- "constraint": "habitation_limitation",- "security_aspect": "natural_barriers",- "economic_aspect": "resource_extraction_focus",- "political_aspect": "population_concentration"- }- },-- "climatic_constraints": {- "arctic": {- "constraint": "seasonal_access_limitation",- "security_aspect": "natural_defense",- "economic_aspect": "resource_extraction_challenges",- "political_aspect": "limited_population_centers"- },- "temperate": {- "constraint": "agricultural_favorability",- "security_aspect": "year_round_operability",- "economic_aspect": "diversified_economy_possible",- "political_aspect": "population_concentration"- },- "arid": {- "constraint": "water_scarcity",- "security_aspect": "resource_conflict_driver",- "economic_aspect": "limited_agriculture",- "political_aspect": "population_distribution_constraints"- }- },-- "hydrographic_constraints": {- "ocean_access": {- "constraint": "trade_projection_capability",- "security_aspect": "naval_power_development",- "economic_aspect": "global_trade_access",- "political_aspect": "power_projection_ability"- },- "landlocked": {- "constraint": "trade_dependence_on_neighbors",- "security_aspect": "strategic_vulnerability",- "economic_aspect": "transportation_cost_increase",- "political_aspect": "diplomatic_constraint"- },- "river_networks": {- "constraint": "internal_connectivity_patterns",- "security_aspect": "invasion_routes_or_barriers",- "economic_aspect": "trade_corridors",- "political_aspect": "cultural_exchange_pathways"- }- }- }-- # Analyze specific event against constraint frameworks- analysis = {- "region": region,- "event": event_data.get("title", "Unknown"),- "identified_constraints": [],- "constraint_levels": {},- "determinism_assessment": "constraint_dominant" if True else "choice_available"- }-- return analysis--def assess_constraint_level(event_data: Dict, constraint_type: str) -> float:- """- Assess how strongly a specific geographic constraint determines an event-- Returns: 0.0 - 1.0 (where 1.0 means complete geographic determinism)- """-- constraint_keywords = {- "topographic": ["mountain", "plain", "valley", "elevation", "terrain", "border"],- "climatic": ["weather", "climate", "season", "temperature", "arctic", "desert"],- "hydrographic": ["ocean", "sea", "river", "water", "port", "coastal", "landlocked"],- "resource": ["oil", "gas", "mineral", "resource", "energy", "agriculture"],- "population": ["urban", "rural", "population", "density", "demographic"]- }-- event_text = (event_data.get("title", "") + " " + event_data.get("description", "")).lower()-- if constraint_type not in constraint_keywords:- return 0.0-- keyword_matches = sum(1 for keyword in constraint_keywords[constraint_type]- if keyword in event_text)-- # Calculate constraint level based on keyword density and context- max_possible = len(constraint_keywords[constraint_type])- constraint_level = keyword_matches / max_possible if max_possible > 0 else 0.0-- return min(constraint_level * 2, 1.0) # Scale to 0-1 range--def identify_geographic_determinants(event_data: Dict) -> List[str]:- """- Identify which geographic constraints are primary determinants of an event- """-- determinants = []-- constraint_levels = {- "topographic": assess_constraint_level(event_data, "topographic"),- "climatic": assess_constraint_level(event_data, "climatic"),- "hydrographic": assess_constraint_level(event_data, "hydrographic"),- "resource": assess_constraint_level(event_data, "resource"),- "population": assess_constraint_level(event_data, "population")- }-- # Select determinants above threshold (0.3 or higher)- for constraint_type, level in constraint_levels.items():- if level >= 0.3:- determinants.append(constraint_type)-- return determinants--def calculate_geographic_determinism_score(event_data: Dict) -> float:- """- Calculate overall geographic determinism score for an event-- Higher score = more geographically determined (less policy choice available)- """-- constraint_levels = {- "topographic": assess_constraint_level(event_data, "topographic"),- "climatic": assess_constraint_level(event_data, "climatic"),- "hydrographic": assess_constraint_level(event_data, "hydrographic"),- "resource": assess_constraint_level(event_data, "resource"),- "population": assess_constraint_level(event_data, "population")- }-- # Weight critical constraints more heavily- weighted_scores = {- "topographic": constraint_levels["topographic"] * 0.25,- "climatic": constraint_levels["climatic"] * 0.20,- "hydrographic": constraint_levels["hydrographic"] * 0.25, # Critical for trade/security- "resource": constraint_levels["resource"] * 0.20, # Critical for economy- "population": constraint_levels["population"] * 0.10- }-- total_score = sum(weighted_scores.values())-- return round(total_score, 3)--def compare_regional_constraints(region1: str, region2: str, event_data: Dict) -> Dict:- """- Compare how geographic constraints affect two regions differently- """-- regional_constraint_profiles = {- "russia": {- "primary_constraints": ["north_european_plain", "warm_water_ports", "vast_territory", "climate"],- "constraint_severity": {"high": 3, "medium": 1, "low": 0}- },- "china": {- "primary_constraints": ["coastal_vulnerability", "unity_challenge", "resource_distribution", "agriculture"],- "constraint_severity": {"high": 2, "medium": 2, "low": 0}- },- "usa": {- "primary_constraints": ["ocean_buffers", "agricultural_abundance", "resource_independence"],- "constraint_severity": {"high": 0, "medium": 1, "low": 2} # Note: advantages, not constraints- },- "middle_east": {- "primary_constraints": ["desert_geography", "oil_curse", "water_scarcity", "colonial_borders"],- "constraint_severity": {"high": 4, "medium": 0, "low": 0}- },- "europe": {- "primary_constraints": ["flat_plains", "geographic_proximity", "multiple_harbors", "river_networks"],- "constraint_severity": {"high": 1, "medium": 2, "low": 1}- }- }-- # Get constraint profiles for both regions- profile1 = regional_constraint_profiles.get(region1.lower(), {})- profile2 = regional_constraint_profiles.get(region2.lower(), {})-- comparison = {- "region1": region1,- "region2": region2,- "region1_constraints": profile1.get("primary_constraints", []),- "region2_constraints": profile2.get("primary_constraints", []),- "constraint_similarity": calculate_constraint_similarity(- profile1.get("primary_constraints", []),- profile2.get("primary_constraints", [])- ),- "determinism_difference": calculate_determinism_difference(profile1, profile2)- }-- return comparison--def calculate_constraint_similarity(constraints1: List[str], constraints2: List[str]) -> float:- """- Calculate similarity between two regions' constraint profiles- """-- set1 = set(constraints1)- set2 = set(constraints2)-- intersection = len(set1.intersection(set2))- union = len(set1.union(set2))-- similarity = intersection / union if union > 0 else 0.0-- return round(similarity, 3)--def calculate_determinism_difference(profile1: Dict, profile2: Dict) -> float:- """- Calculate difference in geographic determinism levels between two regions- """-- def get_determinism_score(profile):- severity = profile.get("constraint_severity", {})- return (severity.get("high", 0) * 1.0 +- severity.get("medium", 0) * 0.5 +- severity.get("low", 0) * 0.1)-- score1 = get_determinism_score(profile1)- score2 = get_determinism_score(profile2)-- difference = abs(score1 - score2)-- return round(difference, 3)--def predict_constraint_driven_behavior(region: str, constraint_type: str, timeframe: str = "medium") -> Dict:- """- Predict behavior based on specific geographic constraints-- Used for generating predictions about how geography will determine future actions- """-- constraint_behaviors = {- "russia": {- "north_european_plain": {- "short_term": "buffer_zone_maintenance",- "medium_term": "eastern_europe_influence",- "long_term": "defensive_depth_strategy"- },- "warm_water_ports": {- "short_term": "crimea_consolidation",- "medium_term": "mediterranean_expansion",- "long_term": "global_naval_presence"- }- },- "china": {- "coastal_vulnerability": {- "short_term": "maritime_security_buildup",- "medium_term": "south_china_sea_control",- "long_term": "blue_water_navy_development"- },- "unity_challenge": {- "short_term": "internal_security_measures",- "medium_term": "infrastructure_development",- "long_term": "economic_integration"- }- },- "middle_east": {- "water_scarcity": {- "short_term": "water_resource_control",- "medium_term": "regional_water_cooperation/conflict",- "long_term": "desalination_investment"- },- "oil_curse": {- "short_term": "price_stability_efforts",- "medium_term": "economic_diversification_attempts",- "long_term": "post_oil_economy_preparation"- }- }- }-- behaviors = constraint_behaviors.get(region.lower(), {}).get(constraint_type, {})- predicted_behavior = behaviors.get(timeframe, "unknown_behavior")-- return {- "region": region,- "constraint": constraint_type,- "timeframe": timeframe,- "predicted_behavior": predicted_behavior,- "confidence": 0.7 # Base confidence for geographic determinism predictions- }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/historical_patterns.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/historical_patterns.pydeleted file mode 100644index 2536a728a..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/historical_patterns.py+++ /dev/null@@ -1,406 +0,0 @@-"""-Historical Patterns Analysis Module-Shared tools for identifying recurring geographic determinism patterns-Based on Tim Marshall's framework that geography creates recurring historical behaviors-"""--from typing import Dict, List, Any, Optional-import json-from datetime import datetime--def identify_historical_patterns(region: str, event_data: Dict) -> Dict[str, Any]:- """- Identify historical patterns that demonstrate geographic determinism-- Core thesis: Geographic constraints create recurring patterns of behavior- throughout history, demonstrating that geography determines rather than influences- geopolitical actions.- """-- pattern_libraries = {- "russia": {- "expansion_patterns": {- "pattern": "territorial_expansion_follows_geographic_insecurity",- "historical_examples": [- "moscow_expansion_for_defensive_depth",- "warm_water_port_acquisition_series",- "siberia_expansion_for_resources_security"- ],- "geographic_driver": "north_european_plain_vulnerability",- "determinism_evidence": "consistent_expansion_regardless_of_regime_type"- },- "security_patterns": {- "pattern": "perpetual_search_for_buffer_zones",- "historical_examples": [- "poland_lithuania_control",- "eastern_europe_sphere_of_influence",- "modern_near_abroad_policy"- ],- "geographic_driver": "flat_invasion_routes",- "determinism_evidence": "buffer_zone_creation across centuries"- },- "economic_patterns": {- "pattern": "resource_control_drives_foreign_policy",- "historical_examples": [- "grain_export_control",- "energy_pipeline_politics",- "arctic_resource_access"- ],- "geographic_driver": "resource_distribution_challenges",- "determinism_evidence": "consistent_resource_focus regardless_of_ideology"- }- },-- "china": {- "unity_patterns": {- "pattern": "infrastructure_development_maintains_unity",- "historical_examples": [- "grand_canal_construction",- "great_wall_building",- "modern_belt_and_road_initiative"- ],- "geographic_driver": "geographic_barriers_to_cohesion",- "determinism_evidence": "consistent_infrastructure_investment across_dynasties"- },- "maritime_patterns": {- "pattern": "coastal_vulnerability_drives_maritime_policy",- "historical_examples": [- "treasure_fleet_period",- "maritime_silk_road",- "modern_south_china_sea_policy"- ],- "geographic_driver": "historical_maritime_invasions",- "determinism_evidence": "recurring_maritime_security_focus"- },- "economic_patterns": {- "pattern": "agricultural_heartland_protection",- "historical_examples": [- "yellow_river_valley_control",- "food_storage_systems",- "modern_agricultural_security"- ],- "geographic_driver": "limited_arable_land",- "determinism_evidence": "consistent_food_security_priority"- }- },-- "middle_east": {- "resource_patterns": {- "pattern": "oil_geography_determines_political_structures",- "historical_examples": [- "pre_oil_tribal_systems",- "oil_state_formation",- "modern_rentier_states"- ],- "geographic_driver": "oil_resource_distribution",- "determinism_evidence": "political_structures_follow_oil_geography"- },- "conflict_patterns": {- "pattern": "water_scarcity_drives_recurring_conflicts",- "historical_examples": [- "ancient_mesopotamian_water_wars",- "ottoman_water_control",- "modern_river_disputes"- ],- "geographic_driver": "arid_climate_water_scarcity",- "determinism_evidence": "water_conflicts_across_millennia"- },- "stability_patterns": {- "pattern": "colonial_borders_create_perpetual_instability",- "historical_examples": [- "sykes_picot_boundaries",- "post-colonial_state_failures",- "modern_separatist_movements"- ],- "geographic_driver": "artificial_colonial_boundaries",- "determinism_evidence": "consistent_instability_along_colonial_lines"- }- },-- "europe": {- "conflict_patterns": {- "pattern": "geographic_proximity_drives_perpetual_competition",- "historical_examples": [- "hundred_years_war",- "napoleonic_wars",- "world_wars"- ],- "geographic_driver": "flat_plains_and_close_proximity",- "determinism_evidence": "recurring_conflict_regardless_of_regime_types"- },- "cooperation_patterns": {- "pattern": "geographic_constraints_drive_integration_attempts",- "historical_examples": [- "holy_roman_empire",- "concert_of_europe",- "european_union"- ],- "geographic_driver": "mutual_vulnerability_and_economic_interdependence",- "determinism_evidence": "recurring_integration_attempts"- },- "maritime_patterns": {- "pattern": "natural_harbors_enable_global_power",- "historical_examples": [- "age_of_exploration",- "colonial_empires",- "modern_trade_dominance"- ],- "geographic_driver": "numerous_natural_harbors",- "determinism_evidence": "consistent_maritime_power_development"- }- },-- "usa": {- "expansion_patterns": {- "pattern": "geographic_security_enables_expansion",- "historical_examples": [- "westward_territorial_expansion",- "monroe_doctrine_implementation",- "global_power_projection"- ],- "geographic_driver": "ocean_buffers_and_security",- "determinism_evidence": "consistent_expansion_when_secure"- },- "economic_patterns": {- "pattern": "resource_abundance_enables_wealth_creation",- "historical_examples": [- "agricultural_export_development",- "industrial_revolution_acceleration",- "energy_independence_achievement"- ],- "geographic_driver": "abundant_natural_resources",- "determinism_evidence": "consistent_economic_advantage_from_resources"- }- }- }-- # Get relevant patterns for the region- regional_patterns = pattern_libraries.get(region.lower(), {})-- # Analyze current event against historical patterns- pattern_matches = []- for pattern_type, pattern_data in regional_patterns.items():- match_score = match_event_to_pattern(event_data, pattern_data)- if match_score > 0.5:- pattern_matches.append({- "pattern_type": pattern_type,- "pattern_name": pattern_data["pattern"],- "match_score": match_score,- "geographic_driver": pattern_data["geographic_driver"],- "historical_examples": pattern_data["historical_examples"]- })-- return {- "region": region,- "event": event_data.get("title", "Unknown"),- "identified_patterns": pattern_matches,- "determinism_evidence": extract_determinism_evidence(pattern_matches),- "pattern_confidence": calculate_pattern_confidence(pattern_matches)- }--def match_event_to_pattern(event_data: Dict, pattern_data: Dict) -> float:- """- Calculate how well an event matches a historical pattern- """-- event_text = (event_data.get("title", "") + " " +- event_data.get("description", "")).lower()-- pattern_keywords = extract_pattern_keywords(pattern_data)-- # Count keyword matches- matches = sum(1 for keyword in pattern_keywords if keyword in event_text)-- # Calculate match score- if len(pattern_keywords) == 0:- return 0.0-- match_score = matches / len(pattern_keywords)-- # Boost score if geographic driver is explicitly mentioned- geographic_driver = pattern_data.get("geographic_driver", "").lower()- if geographic_driver and geographic_driver in event_text:- match_score += 0.2-- return min(match_score, 1.0)--def extract_pattern_keywords(pattern_data: Dict) -> List[str]:- """- Extract keywords that define a historical pattern- """-- keywords = []-- # Extract from pattern name- pattern_name = pattern_data.get("pattern", "").lower()- keywords.extend(pattern_name.split())-- # Extract from historical examples- examples = pattern_data.get("historical_examples", [])- for example in examples:- keywords.extend(example.lower().split())-- # Extract from geographic driver- driver = pattern_data.get("geographic_driver", "").lower()- keywords.extend(driver.split())-- # Remove common words and deduplicate- stop_words = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by"}- keywords = [word for word in keywords if word not in stop_words and len(word) > 2]-- return list(set(keywords))--def extract_determinism_evidence(pattern_matches: List[Dict]) -> List[str]:- """- Extract evidence of geographic determinism from pattern matches- """-- evidence = []-- for match in pattern_matches:- if match["match_score"] > 0.7:- evidence.append(f"Strong_match_to_{match['pattern_type']}_pattern")- evidence.append(f"Geographic_driver_{match['geographic_driver']}")-- # Add historical continuity evidence- examples = match.get("historical_examples", [])- if examples:- evidence.append(f"Historical_continuity_across_{len(examples)}_periods")-- return evidence--def calculate_pattern_confidence(pattern_matches: List[Dict]) -> float:- """- Calculate overall confidence in pattern identification- """-- if not pattern_matches:- return 0.0-- # Weight by match scores- total_weight = sum(match["match_score"] for match in pattern_matches)- max_possible = len(pattern_matches)-- confidence = total_weight / max_possible if max_possible > 0 else 0.0-- return round(confidence, 3)--def compare_historical_patterns(region1: str, region2: str) -> Dict:- """- Compare historical patterns between two regions to identify- common geographic determinism themes- """-- pattern_libraries = {- "russia": ["expansion_for_security", "buffer_zone_creation", "resource_control"],- "china": ["infrastructure_unity", "maritime_security", "agricultural_protection"],- "middle_east": ["resource_curse", "water_conflicts", "colonial_instability"],- "europe": ["perpetual_competition", "integration_attempts", "maritime_power"],- "usa": ["security_enabled_expansion", "resource_abundance", "power_projection"]- }-- patterns1 = pattern_libraries.get(region1.lower(), [])- patterns2 = pattern_libraries.get(region2.lower(), [])-- # Find common patterns- common_patterns = set(patterns1) & set(patterns2)- unique_patterns1 = set(patterns1) - set(patterns2)- unique_patterns2 = set(patterns2) - set(patterns1)-- comparison = {- "region1": region1,- "region2": region2,- "common_patterns": list(common_patterns),- "unique_to_region1": list(unique_patterns1),- "unique_to_region2": list(unique_patterns2),- "pattern_similarity": len(common_patterns) / max(len(patterns1), len(patterns2), 1)- }-- return comparison--def predict_pattern_continuation(region: str, pattern_type: str, timeframe: str = "medium") -> Dict:- """- Predict continuation of historical patterns based on geographic determinism- """-- pattern_predictions = {- "russia": {- "expansion_for_security": {- "short_term": "buffer_zone_maintenance",- "medium_term": "strategic_depth_preservation",- "long_term": "perimeter_security_ensurance"- },- "resource_control": {- "short_term": "energy_leverage_maintenance",- "medium_term": "export_route_security",- "long_term": "resource_sphere_dominance"- }- },- "china": {- "infrastructure_unity": {- "short_term": "connectivity_projects",- "medium_term": "economic_integration",- "long_term": "comprehensive_unity_achievement"- },- "maritime_security": {- "short_term": "coastal_defense",- "medium_term": "regional_maritime_control",- "long_term": "global_maritime_presence"- }- },- "middle_east": {- "water_conflicts": {- "short_term": "resource_control",- "medium_term": "cooperation_or_conflict_cycles",- "long_term": "technological_solutions_or_escalation"- },- "colonial_instability": {- "short_term": "regime_survival_focus",- "medium_term": "state_weakening_or_strengthening",- "long_term": "boundary_redrawing_or_stabilization"- }- }- }-- predictions = pattern_predictions.get(region.lower(), {}).get(pattern_type, {})- predicted_behavior = predictions.get(timeframe, "pattern_continuation_expected")-- return {- "region": region,- "pattern_type": pattern_type,- "timeframe": timeframe,- "predicted_behavior": predicted_behavior,- "confidence": 0.8, # High confidence in historical pattern continuation- "determinism_basis": "geographic_constraints_create_recurring_behaviors"- }--def validate_historical_determinism(region: str, event_data: Dict) -> Dict:- """- Validate that an event demonstrates geographic determinism- by showing historical pattern continuity- """-- # Identify matching historical patterns- pattern_analysis = identify_historical_patterns(region, event_data)-- # Assess determinism evidence strength- pattern_matches = pattern_analysis.get("identified_patterns", [])- high_confidence_matches = [p for p in pattern_matches if p["match_score"] > 0.7]-- # Calculate determinism validation score- if high_confidence_matches:- determinism_score = 0.8 + (0.2 * (len(high_confidence_matches) / len(pattern_matches)))- else:- determinism_score = 0.0-- validation = {- "region": region,- "event": event_data.get("title", "Unknown"),- "determinism_validated": determinism_score > 0.7,- "validation_score": round(determinism_score, 3),- "supporting_patterns": len(high_confidence_matches),- "historical_continuity": pattern_analysis.get("determinism_evidence", []),- "marshall_compliance": determinism_score >= 0.7- }-- return validation\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/strategic_imperatives.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/strategic_imperatives.pydeleted file mode 100644index 9543f049e..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/geographic_modules/strategic_imperatives.py+++ /dev/null@@ -1,435 +0,0 @@-"""-Strategic Imperatives Analysis Module-Shared tools for calculating strategic imperatives driven by geographic constraints-Based on Tim Marshall's framework that geography creates unavoidable strategic imperatives-"""--from typing import Dict, List, Any, Optional-import json-from datetime import datetime--def calculate_strategic_imperatives(region: str, geographic_analysis: List[Dict]) -> Dict[str, Any]:- """- Calculate strategic imperatives based on geographic constraints-- Core thesis: Geographic constraints create unavoidable strategic imperatives- that nations must pursue regardless of leadership or ideology- """-- imperatives_framework = {- "russia": {- "primary_imperatives": [- {- "imperative": "maintain_buffer_zones_in_eastern_europe",- "geographic_driver": "north_european_plain_vulnerability",- "marshall_justification": "flat_invasion_routes_require_defensive_depth",- "urgency": "critical",- "historical_continuity": "napoleon_to_nato"- },- {- "imperative": "secure_year_round_warm_water_ports",- "geographic_driver": "ice_bound_ports_limitation",- "marshall_justification": "ice_free_ports_required_for_naval_power",- "urgency": "critical",- "historical_continuity": "peter_great_to_present"- }- ],- "secondary_imperatives": [- {- "imperative": "control_agricultural_heartland",- "geographic_driver": "limited_arable_land_concentration",- "marshall_justification": "food_security_requires_ukraine_control",- "urgency": "high"- },- {- "imperative": "develop_arctic_transport_corridors",- "geographic_driver": "vast_territory_challenge",- "marshall_justification": "territorial_size_requires_transport_control",- "urgency": "medium"- }- ]- },-- "china": {- "primary_imperatives": [- {- "imperative": "create_maritime_security_bubble",- "geographic_driver": "coastal_vulnerability_history",- "marshall_justification": "maritime_invasions_require_defensive_layers",- "urgency": "critical",- "historical_continuity": "century_of_humiliation_to_present"- },- {- "imperative": "maintain_national_unity_through_infrastructure",- "geographic_driver": "geographic_unity_challenges",- "marshall_justification": "mountains_rivers_separate_require_connection",- "urgency": "critical",- "historical_continuity": "silk_road_to_belt_and_road"- }- ],- "secondary_imperatives": [- {- "imperative": "secure_energy_import_routes",- "geographic_driver": "resource_distribution_imbalance",- "marshall_justification": "energy_far_from_population_requires_security",- "urgency": "high"- },- {- "imperative": "protect_agricultural_heartlands",- "geographic_driver": "limited_arable_land_pressure",- "marshall_justification": "feeding_population_requires_food_security",- "urgency": "high"- }- ]- },-- "usa": {- "primary_imperatives": [- {- "imperative": "maintain_global_power_projection_capability",- "geographic_driver": "ocean_buffer_security",- "marshall_justification": "secure_borders_enable_global_engagement",- "urgency": "critical",- "historical_continuity": "monroe_doctrine_to_present"- },- {- "imperative": "exercise_global_food_system_influence",- "geographic_driver": "agricultural_abundance",- "marshall_justification": "food_surplus Creates_export_power",- "urgency": "high",- "historical_continuity": "agricultural_exports_to_food_diplomacy"- }- ],- "secondary_imperatives": [- {- "imperative": "leverage_energy_independence",- "geographic_driver": "domestic_resource_availability",- "marshall_justification": "energy_independence Creates_economic_leverage",- "urgency": "medium"- }- ]- },-- "middle_east": {- "primary_imperatives": [- {- "imperative": "maintain_oil_price_stability",- "geographic_driver": "oil_resource_geography",- "marshall_justification": "oil_dependence_requires_price_control",- "urgency": "critical",- "historical_continuity": "oil_discoveries_to_opec_wars"- },- {- "imperative": "secure_water_resource_control",- "geographic_driver": "arid_climate_water_scarcity",- "marshall_justification": "water_scarcity_creates_zero_sum_competition",- "urgency": "critical",- "historical_continuity": "ancient_water_wars_to_present"- }- ],- "secondary_imperatives": [- {- "imperative": "maintain_regime_survival",- "geographic_driver": "colonial_border_instability",- "marshall_justification": "artificial_states_create_internal_threats",- "urgency": "high"- }- ]- },-- "europe": {- "primary_imperatives": [- {- "imperative": "maintain_collective_security_systems",- "geographic_driver": "flat_plain_invasion_vulnerability",- "marshall_justification": "mutual_vulnerability_requires_alliance",- "urgency": "critical",- "historical_continuity": "concert_of_europe_to_nato"- },- {- "imperative": "balance_cooperation_and_competition",- "geographic_driver": "geographic_proximity_interaction",- "marshall_justification": "close_neighbors_force_constant_interaction",- "urgency": "critical",- "historical_continuity": "holy_roman_empire_to_eu"- }- ],- "secondary_imperatives": [- {- "imperative": "preserve_internal_trade_connectivity",- "geographic_driver": "navigable_river_networks",- "marshall_justification": "rivers_enable_economic_integration",- "urgency": "medium"- }- ]- }- }-- # Get region-specific imperatives- regional_imperatives = imperatives_framework.get(region.lower(), {})-- # Analyze current events to determine active imperatives- active_imperatives = identify_active_imperatives(- geographic_analysis, regional_imperatives- )-- # Calculate urgency levels based on current events- urgency_assessment = assess_imperative_urgency(- active_imperatives, geographic_analysis- )-- return {- "region": region,- "primary_imperatives": active_imperatives.get("primary", []),- "secondary_imperatives": active_imperatives.get("secondary", []),- "urgency_assessment": urgency_assessment,- "geographic_drivers": extract_geographic_drivers(active_imperatives),- "historical_continuity": assess_historical_continuity(active_imperatives)- }--def identify_active_imperatives(geographic_analysis: List[Dict], regional_imperatives: Dict) -> Dict:- """- Identify which strategic imperatives are active based on current events- """-- active_imperatives = {- "primary": [],- "secondary": []- }-- # Count geographic determinant frequency- determinant_counts = {}- for analysis in geographic_analysis:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Map determinants to imperatives- determinant_to_imperative_map = {- "north_european_plain_vulnerability": "maintain_buffer_zones_in_eastern_europe",- "warm_water_port_obsession": "secure_year_round_warm_water_ports",- "coastal_vulnerability": "create_maritime_security_bubble",- "unity_challenge": "maintain_national_unity_through_infrastructure",- "oil_resource_curse": "maintain_oil_price_stability",- "water_scarcity": "secure_water_resource_control",- "flat_plains": "maintain_collective_security_systems",- "geographic_proximity": "balance_cooperation_and_competition"- }-- # Activate imperatives based on determinant frequency- for determinant, count in determinant_counts.items():- if count > 0 and determinant in determinant_to_imperative_map:- imperative_name = determinant_to_imperative_map[determinant]-- # Find imperative in regional framework- for imperative in regional_imperatives.get("primary_imperatives", []):- if imperative["imperative"] == imperative_name:- active_imperatives["primary"].append(imperative)- break-- for imperative in regional_imperatives.get("secondary_imperatives", []):- if imperative["imperative"] == imperative_name:- active_imperatives["secondary"].append(imperative)- break-- return active_imperatives--def assess_imperative_urgency(active_imperatives: Dict, geographic_analysis: List[Dict]) -> Dict:- """- Assess urgency levels for active strategic imperatives- """-- urgency_levels = {}-- # Base urgency from framework- for imperative in active_imperatives.get("primary", []):- imperative_name = imperative["imperative"]- base_urgency = imperative.get("urgency", "medium")- urgency_levels[imperative_name] = base_urgency-- # Adjust urgency based on current events- event_frequency = len(geographic_analysis)- if event_frequency >= 5:- # High event frequency increases urgency- for imperative_name in urgency_levels:- if urgency_levels[imperative_name] == "medium":- urgency_levels[imperative_name] = "high"- elif urgency_levels[imperative_name] == "high":- urgency_levels[imperative_name] = "critical"-- return urgency_levels--def extract_geographic_drivers(active_imperatives: Dict) -> List[str]:- """- Extract geographic drivers for active strategic imperatives- """-- drivers = set()-- for imperative in active_imperatives.get("primary", []):- drivers.add(imperative.get("geographic_driver", "unknown"))-- for imperative in active_imperatives.get("secondary", []):- drivers.add(imperative.get("geographic_driver", "unknown"))-- return list(drivers)--def assess_historical_continuity(active_imperatives: Dict) -> Dict:- """- Assess historical continuity of active strategic imperatives- """-- continuity_assessment = {}-- for imperative in active_imperatives.get("primary", []):- imperative_name = imperative["imperative"]- historical_continuity = imperative.get("historical_continuity", "unknown")-- continuity_assessment[imperative_name] = {- "historical_pattern": historical_continuity,- "continuity_strength": "strong" if historical_continuity != "unknown" else "weak",- "determinism_evidence": "geographic_constraint_drives_continuity"- }-- return continuity_assessment--def compare_regional_imperatives(region1: str, region2: str) -> Dict:- """- Compare strategic imperatives between two regions- """-- # Get strategic imperatives for both regions- imperatives1 = calculate_strategic_imperatives(region1, [])- imperatives2 = calculate_strategic_imperatives(region2, [])-- # Extract imperative themes- themes1 = [imp["imperative"] for imp in imperatives1.get("primary_imperatives", [])]- themes2 = [imp["imperative"] for imp in imperatives2.get("primary_imperatives", [])]-- # Find common themes- common_themes = set()- for theme1 in themes1:- for theme2 in themes2:- if (theme1 in theme2) or (theme2 in theme1) or ("security" in theme1 and "security" in theme2):- common_themes.add(f"{theme1}/{theme2}")-- comparison = {- "region1": region1,- "region2": region2,- "region1_imperatives": themes1,- "region2_imperatives": themes2,- "common_themes": list(common_themes),- "geographic_driver_similarity": calculate_driver_similarity(imperatives1, imperatives2)- }-- return comparison--def calculate_driver_similarity(imperatives1: Dict, imperatives2: Dict) -> float:- """- Calculate similarity between geographic drivers of two regions- """-- drivers1 = set(extract_geographic_drivers({- "primary": imperatives1.get("primary_imperatives", []),- "secondary": imperatives1.get("secondary_imperatives", [])- }))-- drivers2 = set(extract_geographic_drivers({- "primary": imperatives2.get("primary_imperatives", []),- "secondary": imperatives2.get("secondary_imperatives", [])- }))-- if not drivers1 and not drivers2:- return 1.0 # Both empty means identical-- if not drivers1 or not drivers2:- return 0.0 # One empty means no similarity-- intersection = len(drivers1.intersection(drivers2))- union = len(drivers1.union(drivers2))-- similarity = intersection / union if union > 0 else 0.0-- return round(similarity, 3)--def predict_imperative_evolution(region: str, timeframe: str = "medium") -> Dict:- """- Predict how strategic imperatives will evolve based on geographic constraints- """-- evolution_predictions = {- "russia": {- "short_term": "buffer_zone_maintenance_intensifies",- "medium_term": "arctic_development_accelerates",- "long_term": "warm_water_port_competition_increases"- },- "china": {- "short_term": "maritime_security_expansion_continues",- "medium_term": "infrastructure_connectivity_deepens",- "long_term": "global_energy_network_establishment"- },- "middle_east": {- "short_term": "oil_price_management_intensifies",- "medium_term": "water_cooperation_or_conflict_cycles",- "long_term": "economic_diversification_urgent"- }- }-- predictions = evolution_predictions.get(region.lower(), {})- predicted_evolution = predictions.get(timeframe, "imperative_continuation_expected")-- return {- "region": region,- "timeframe": timeframe,- "predicted_evolution": predicted_evolution,- "confidence": 0.8,- "geographic_basis": "constraints_create_imperative_persistence"- }--def validate_imperative_compliance(analysis_result: Dict) -> Dict:- """- Validate that strategic imperatives meet Marshall's geographic determinism requirements- """-- strategic_imperatives = analysis_result.get("strategic_imperatives", {})- primary_imperatives = strategic_imperatives.get("primary_imperatives", [])-- # Check compliance criteria- compliance_checks = {- "sufficient_primary_imperatives": len(primary_imperatives) >= 2,- "geographic_drivers_identified": bool(strategic_imperatives.get("geographic_drivers")),- "historical_continuity_shown": bool(strategic_imperatives.get("historical_continuity")),- "urgency_levels_assigned": bool(strategic_imperatives.get("urgency_assessment"))- }-- # Calculate overall compliance score- compliance_score = sum(compliance_checks.values()) / len(compliance_checks)-- validation = {- "compliance_score": round(compliance_score, 3),- "meets_marshall_requirements": compliance_score >= 0.75,- "compliance_checks": compliance_checks,- "recommendations": generate_compliance_recommendations(compliance_checks)- }-- return validation--def generate_compliance_recommendations(compliance_checks: Dict) -> List[str]:- """- Generate recommendations to improve Marshall compliance- """-- recommendations = []-- if not compliance_checks.get("sufficient_primary_imperatives", False):- recommendations.append("Increase primary strategic imperatives to minimum 2")-- if not compliance_checks.get("geographic_drivers_identified", False):- recommendations.append("Clearly identify geographic drivers for each imperative")-- if not compliance_checks.get("historical_continuity_shown", False):- recommendations.append("Demonstrate historical continuity of imperatives")-- if not compliance_checks.get("urgency_levels_assigned", False):- recommendations.append("Assign appropriate urgency levels to imperatives")-- return recommendations\ No newline at end of filediff --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.pyindex 9dc64dc08..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-AFRICA GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 5+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - African geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# -region="africa"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: Africa is shaped by geography - colonial boundaries ignore natural-geography, Sahara desert creates north-south division, disease belts limit development,-and rich resources create external exploitation patterns.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def africa_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- AFRICA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: African politics is SHAPED by geographic features:- 1. Colonial Boundaries → artificial states ignoring natural geography- 2. Sahara Desert → north-south geographic and cultural division- 3. Disease Belts → tsetse fly, malaria limit development and population- 4. Resource Richness → minerals, oil creating external exploitation patterns-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "africa_geography_agent"- print(f"🏔️ Africa Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Africa's Geographic Constraints (Marshall's Framework)- african_geographic_constraints = {- "colonial_boundaries": {- "constraint": "Artificial boundaries ignoring natural geography",- "instability_effect": "Unnatural state creation, ethnic group separation",- "strategic_imperative": "Overcoming artificial divisions for stability",- "current_implications": "Separatist movements, state weakness, border conflicts"+ # 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"},-- "sahara_desert": {- "constraint": "Vast desert creating north-south division",- "geographic_barrier": "Cultural, economic, climatic separation",- "strategic_imperative": "Cross-desert connectivity and cooperation",- "current_implications": "Sahel conflicts, migration routes, trade barriers"+ "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"},-- "disease_belts": {- "constraint": "Tropical diseases limiting development",- "development_constraint": "Malaria, tsetse fly affect population and agriculture",- "strategic_imperative": "Health infrastructure development",- "current_implications": "Development challenges, population distribution, health crises"+ "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"},-- "resource_richness": {- "constraint": "Abundant natural resources",- "external_interference": "Minerals, oil, diamonds attract external exploitation",- "strategic_imperative": "Resource sovereignty and benefit management",- "current_implications": "Resource conflicts, Chinese investment, resource nationalism"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, african_geographic_constraints- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_african_strategic_imperatives(- geographic_analysis, african_geographic_constraints- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_african_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "africa",- "timestamp": datetime.now().isoformat(),-- # Geographic constraint analysis- "geographic_constraints": african_geographic_constraints,- "constraint_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic constraints- "geographic_predictions": predict_african_behavior(- geographic_analysis, african_geographic_constraints- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, african_geographic_constraints),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, african_geographic_constraints)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Africa Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_constraints: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "constraint_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Colonial boundaries analysis- boundary_keywords = ["border", "separatist", "ethnic", "colonial", "boundary", "state", "conflict"]- if any(keyword in event_title or keyword in event_description for keyword in boundary_keywords):- analysis["geographic_determinants"].append("colonial_boundaries")- analysis["constraint_drivers"].append("artificial_state_boundaries_instability")- analysis["strategic_imperatives"].append("overcoming_colonial_divisions")- analysis["marshall_determinism_score"] += 0.25-- # Sahara Desert analysis- desert_keywords = ["sahara", "sahel", "desert", "north africa", "migration", "niger", "mali", "chad"]- if any(keyword in event_title or keyword in event_description for keyword in desert_keywords):- analysis["geographic_determinants"].append("sahara_desert")- analysis["constraint_drivers"].append("desert_geographic_north_south_division")- analysis["strategic_imperatives"].append("cross_desert_connectivity")- analysis["marshall_determinism_score"] += 0.25-- # Disease belts analysis- disease_keywords = ["malaria", "health", "disease", "ebola", "hiv", "tsetse", "development"]- if any(keyword in event_title or keyword in event_description for keyword in disease_keywords):- analysis["geographic_determinants"].append("disease_belts")- analysis["constraint_drivers"].append("tropical_disease_development_constraints")- analysis["strategic_imperatives"].append("health_infrastructure_development")- analysis["marshall_determinism_score"] += 0.25-- # Resource richness analysis- resource_keywords = ["mining", "oil", "diamonds", "cobalt", "lithium", "resource", "china", "investment"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("resource_richness")- analysis["constraint_drivers"].append("resource_abundance_external_exploitation_pattern")- analysis["strategic_imperatives"].append("resource_sovereignty_management")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_african_strategic_imperatives(analysis_results: List[Dict], geographic_constraints: Dict) -> Dict:- """- Calculate African strategic imperatives based on geographic constraints (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("colonial_boundaries", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "overcome_artificial_colonial_boundaries_for_stability",- "geographic_driver": "colonial_boundaries",- "marshall_justification": "artificial_boundaries_create_inherent_instability",- "urgency": "critical",- "historical_continuity": "colonial_creation_to_modern_separatism"- })-- if determinant_counts.get("resource_richness", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "manage_resource_sovereignty_against_external_exploitation",- "geographic_driver": "resource_richness",- "marshall_justification": "resource_abundance_attracts_external_exploitation_patterns",- "urgency": "critical",- "historical_continuity": "colonial_extraction_to_modern_resource_politics"- })-- # Secondary imperatives (geographic constraints)- if determinant_counts.get("sahara_desert", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "develop_cross_desert_connectivity_and_cooperation",- "geographic_driver": "sahara_desert",- "marshall_justification": "desert_barrier_requires_overcoming_for_unity",- "urgency": "high"- })-- if determinant_counts.get("disease_belts", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "build_health_infrastructure_to_overcome_disease_constraints",- "geographic_driver": "disease_belts",- "marshall_justification": "tropical_diseases_limit_development_and_population",- "urgency": "high"- })-- return imperatives--def identify_african_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "boundary_patterns": {- "pattern": "colonial_boundaries_create_perpetual_instability",- "examples": [- "artificial_state_creation_berlin_conference",- "post-colonial_border_conflicts",- "modern_separatist_movements"- ],- "geographic_determinism": True- },-- "resource_patterns": {- "pattern": "resource_geography_drives_external_interference_cycles",- "examples": [- "colonial_resource_extraction",- "cold_war_proxy_conflicts_over_resources",- "modern_chinese_resource_investment"- ],- "geographic_determinism": True- },-- "development_patterns": {- "pattern": "geographic_constraints_create_development_challenges",- "examples": [- "disease_belt_population_constraints",- "sahara_desert_trade_barriers",- "infrastructure_development_difficulties"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("boundary_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("resource_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("development_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_african_behavior(analysis_results: List[Dict], geographic_constraints: Dict) -> List[Dict]:- """- Predict African behavior based on geographic constraints (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_constraints = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_constraints.add(determinant)-- # Predict behaviors based on active geographic constraints-- if "colonial_boundaries" in active_constraints:- predictions.append({- "prediction": "continued_separatist_movements_and_state_weakness",- "geographic_driver": "colonial_boundaries",- "marshall_justification": "artificial_boundaries_create_inherent_instability",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "resource_richness" in active_constraints:- predictions.append({- "prediction": "increased_external_competition_for_african_resources",- "geographic_driver": "resource_richness",- "marshall_justification": "resource_abundance_attracts_external_powers",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "sahara_desert" in active_constraints:- predictions.append({- "prediction": "sahel_region_instability_and_migration_challenges",- "geographic_driver": "sahara_desert",- "marshall_justification": "desert_barrier_creates_north_south_tensions",- "confidence": 0.8,- "timeframe": "ongoing"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_constraints: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_constraints: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic constraints are driving this event?- - How do these constraints limit African strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 3690ff8ff..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-ARCTIC GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 10+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Arctic geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="arctic"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: The Arctic is emerging from geographic isolation - climate change is-opening new sea routes, revealing rich resources, and creating international competition-in previously inaccessible territory.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def arctic_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- ARCTIC GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Arctic politics is BEING SHAPED by changing geographic features:- 1. Climate Change → ice melt opening new sea routes and access- 2. Resource Richness → oil, gas, minerals becoming accessible- 3. Strategic Location → shortest route between Europe and Asia- 4. Multiple Border States → eight nations competing for control-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "arctic_geography_agent"- print(f"🏔️ Arctic Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Arctic's Geographic Features (Marshall's Framework)- arctic_geographic_features = {- "climate_change_transformation": {- "feature": "Warming climate opening previously inaccessible areas",- "transformation_effect": "New sea routes, resource access, military presence",- "strategic_imperative": "Establish presence before competitors",- "current_implications": "Northern Sea Route development, Arctic militarization"+ # 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"},-- "resource_richness": {- "feature": "Abundant untapped oil, gas, and mineral resources",- "economic_opportunity": "13% of undiscovered oil, 30% of natural gas",- "strategic_imperative": "Resource claims and extraction rights",- "current_implications": "Arctic oil development, mineral claims, energy competition"+ "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"},-- "strategic_shipping_location": {- "feature": "Shortest maritime route between Europe and Asia",- "economic_advantage": "40% distance reduction compared to Suez Canal",- "strategic_imperative": "Control of Arctic shipping lanes",- "current_implications": "Northern Sea Route development, shipping competition"+ "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"},-- "multiple_border_complexity": {- "feature": "Eight Arctic nations with competing claims",- "geopolitical_complexity": "Russia, US, Canada, Denmark, Norway, Sweden, Finland, Iceland",- "strategic_imperative": "International cooperation and competition balance",- "current_implications": "Arctic Council, territorial disputes, military exercises"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, arctic_geographic_features- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_arctic_strategic_imperatives(- geographic_analysis, arctic_geographic_features- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_arctic_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "arctic",- "timestamp": datetime.now().isoformat(),-- # Geographic feature analysis- "geographic_features": arctic_geographic_features,- "feature_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic features- "geographic_predictions": predict_arctic_behavior(- geographic_analysis, arctic_geographic_features- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, arctic_geographic_features),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, arctic_geographic_features)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Arctic Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_features: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "feature_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Climate Change analysis- climate_keywords = ["climate", "warming", "ice", "melting", "arctic", "temperature", "environment"]- if any(keyword in event_title or keyword in event_description for keyword in climate_keywords):- analysis["geographic_determinants"].append("climate_change_transformation")- analysis["feature_drivers"].append("warming_climate_opening_previously_inaccessible_areas")- analysis["strategic_imperatives"].append("establish_presence_before_competitors")- analysis["marshall_determinism_score"] += 0.25-- # Resource Richness analysis- resource_keywords = ["oil", "gas", "mineral", "energy", "resource", "exploration", "extraction"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("resource_richness")- analysis["feature_drivers"].append("abundant_untapped_resources_becoming_accessible")- analysis["strategic_imperatives"].append("resource_claims_extraction_rights")- analysis["marshall_determinism_score"] += 0.25-- # Strategic Shipping analysis- shipping_keywords = ["shipping", "route", "northern", "sea", "transit", "navigation", "arctic_route"]- if any(keyword in event_title or keyword in event_description for keyword in shipping_keywords):- analysis["geographic_determinants"].append("strategic_shipping_location")- analysis["feature_drivers"].append("shortest_europe_asia_maritime_route_advantage")- analysis["strategic_imperatives"].append("control_arctic_shipping_lanes")- analysis["marshall_determinism_score"] += 0.25-- # Multiple Border Complexity analysis- border_keywords = ["russia", "canada", "us", "norway", "denmark", "arctic_council", "territorial", "claim"]- if any(keyword in event_title or keyword in event_description for keyword in border_keywords):- analysis["geographic_determinants"].append("multiple_border_complexity")- analysis["feature_drivers"].append("eight_arctic_nations_competing_claims_complexity")- analysis["strategic_imperatives"].append("international_cooperation_competition_balance")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_arctic_strategic_imperatives(analysis_results: List[Dict], geographic_features: Dict) -> Dict:- """- Calculate Arctic strategic imperatives based on geographic features (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("climate_change_transformation", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "establish_arctic_presence_before_climate_opportunity_closes",- "geographic_driver": "climate_change_transformation",- "marshall_justification": "warming_arctic_temporarily_opens_geographic_opportunities",- "urgency": "critical",- "historical_continuity": "age_of_exploration_to_modern_arctic_race"- })-- if determinant_counts.get("resource_richness", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "secure_arctic_resource_claims_and_extraction_rights",- "geographic_driver": "resource_richness",- "marshall_justification": "resource_abundance_becoming_accessible_creates_opportunity_urgency",- "urgency": "critical",- "historical_continuity": "colonial_resource_races_to_modern_energy_competition"- })-- # Secondary imperatives (geographic features)- if determinant_counts.get("strategic_shipping_location", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "develop_control_over_arctic_shipping_routes",- "geographic_driver": "strategic_shipping_location",- "marshall_justification": "geographic_route_advantage_requires_control_establishment",- "urgency": "high"- })-- if determinant_counts.get("multiple_border_complexity", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "balance_international_cooperation_with_national_competition",- "geographic_driver": "multiple_border_complexity",- "marshall_justification": "shared_geographic_space_requires_cooperative_competitive_balance",- "urgency": "high"- })-- return imperatives--def identify_arctic_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "exploration_patterns": {- "pattern": "geographic_inaccessibility_drives_exploration_and_claim_races",- "examples": [- "age_of_exploration_northwest_passage_search",- "cold_war_arctic_military_presence",- "modern_climate-driven_arctic_race"- ],- "geographic_determinism": True- },-- "resource_patterns": {- "pattern": "resource_discovery_drives_territorial_competition",- "examples": [- "alaska_gold_rush_territorial_claims",- "north_sea_oil_development",- "modern_arctic_resource_claims"- ],- "geographic_determinism": True- },-- "climate_patterns": {- "pattern": "climate_change_creates_new_geographic_opportunities_and_competition",- "examples": [- "ice_age_migration_patterns",- "medieval_warming_period_norse_settlement",- "modern_arctic_access_opportunities"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("exploration_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("resource_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("climate_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_arctic_behavior(analysis_results: List[Dict], geographic_features: Dict) -> List[Dict]:- """- Predict Arctic behavior based on geographic features (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_features = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_features.add(determinant)-- # Predict behaviors based on active geographic features-- if "climate_change_transformation" in active_features:- predictions.append({- "prediction": "accelerated_arctic_militarization_and_presence_establishment",- "geographic_driver": "climate_change_transformation",- "marshall_justification": "warming_arctic_temporarily_opens_geographic_opportunities",- "confidence": 0.9,- "timeframe": "short_term (1-3 years)"- })-- if "resource_richness" in active_features:- predictions.append({- "prediction": "increased_arctic_resource_extraction_and_territorial_claims",- "geographic_driver": "resource_richness",- "marshall_justification": "resource_accessibility_creates_urgent_competition",- "confidence": 0.8,- "timeframe": "medium_term (3-7 years)"- })-- if "strategic_shipping_location" in active_features:- predictions.append({- "prediction": "northern_sea_route_commercial_shipping_expansion",- "geographic_driver": "strategic_shipping_location",- "marshall_justification": "route_advantage_drives_shipping_development",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_features: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_features: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic changes are driving this event?- - How is climate change transforming Arctic strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex d5d7038d5..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-CHINA GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 2+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Chinese geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="china"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: China is a prisoner of its geography - coastal vulnerability drives-maritime expansion, unity challenges force internal control, and resource distribution-creates energy security obsessions.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def china_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- CHINA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Chinese foreign policy is DETERMINED by geographic constraints:- 1. Coastal vulnerability → maritime expansion, South China Sea control- 2. Unity challenge → internal control mechanisms, infrastructure development- 3. Resource distribution → energy security obsession, Belt and Road Initiative- 4. Agricultural concentration → food security focus, agricultural heartland protection-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "china_geography_agent"- print(f"🏔️ China Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # China's Geographic Constraints (Marshall's Framework)- chinese_geographic_prisons = {- "coastal_vulnerability": {- "constraint": "Historically vulnerable coastlines",- "historical_vulnerability": "Century of Humiliation, maritime invasions",- "strategic_imperative": "Maritime security and blue water navy",- "current_implications": "South China Sea, Taiwan Strait, naval expansion"+ # 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"},-- "unity_challenge": {- "constraint": "Geographic barriers to national cohesion",- "internal_divisions": "Mountains, deserts, rivers separate regions",- "strategic_imperative": "Infrastructure connectivity, internal control",- "current_implications": "Belt and Road, Great Firewall, internal security"+ "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"},-- "resource_distribution": {- "constraint": "Energy resources far from population centers",- "energy_insecurity": "Coal in north, oil/gas imports needed",- "strategic_imperative": "Energy import route security",- "current_implications": "Belt and Road, String of Pearls, South China Sea"+ "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"},-- "agricultural_concentration": {- "constraint": "Limited arable land in eastern plains",- "food_security_issue": "Feeding 1.4 billion with limited farmland",- "strategic_imperative": "Agricultural heartland control, food imports",- "current_implications": "Agricultural modernization, overseas farming"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, chinese_geographic_prisons- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_chinese_strategic_imperatives(- geographic_analysis, chinese_geographic_prisons- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_chinese_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "china",- "timestamp": datetime.now().isoformat(),-- # Geographic constraint analysis- "geographic_prisons": chinese_geographic_prisons,- "constraint_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic constraints- "geographic_predictions": predict_chinese_behavior(- geographic_analysis, chinese_geographic_prisons- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, chinese_geographic_prisons),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, chinese_geographic_prisons)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in China Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_prisons: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "constraint_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Coastal vulnerability analysis- coastal_keywords = ["south china sea", "taiwan", "maritime", "naval", "coast", "island", "sea"]- if any(keyword in event_title or keyword in event_description for keyword in coastal_keywords):- analysis["geographic_determinants"].append("coastal_vulnerability")- analysis["constraint_drivers"].append("historical_maritime_invasion_fears")- analysis["strategic_imperatives"].append("maritime_security_bubble_creation")- analysis["marshall_determinism_score"] += 0.25-- # Unity challenge analysis- unity_keywords = ["infrastructure", "rail", "belt and road", "internal", "xinjiang", "tibet"]- if any(keyword in event_title or keyword in event_description for keyword in unity_keywords):- analysis["geographic_determinants"].append("unity_challenge")- analysis["constraint_drivers"].append("geographic_barriers_to_national_cohesion")- analysis["strategic_imperatives"].append("infrastructure_connectivity")- analysis["marshall_determinism_score"] += 0.25-- # Resource distribution analysis- resource_keywords = ["energy", "oil", "gas", "pipeline", "import", "string of pearls"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("resource_distribution")- analysis["constraint_drivers"].append("energy_resources_far_from_population")- analysis["strategic_imperatives"].append("energy_import_route_security")- analysis["marshall_determinism_score"] += 0.25-- # Agricultural concentration analysis- agriculture_keywords = ["agriculture", "food", "grain", "farming", "import", "land"]- if any(keyword in event_title or keyword in event_description for keyword in agriculture_keywords):- analysis["geographic_determinants"].append("agricultural_concentration")- analysis["constraint_drivers"].append("limited_arable_land_constraint")- analysis["strategic_imperatives"].append("food_security_assurance")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_chinese_strategic_imperatives(analysis_results: List[Dict], geographic_prisons: Dict) -> Dict:- """- Calculate China's strategic imperatives based on geographic constraints (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("coastal_vulnerability", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "create_maritime_security_bubble",- "geographic_driver": "coastal_vulnerability",- "marshall_justification": "historical_maritime_vulnerability_requires_buffer_zones",- "urgency": "critical",- "historical_continuity": "century_of_humiliation_to_present_day"- })-- if determinant_counts.get("unity_challenge", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_national_unity_through_infrastructure",- "geographic_driver": "unity_challenge",- "marshall_justification": "geographic_barriers_require_connectivity_solutions",- "urgency": "critical",- "historical_continuity": "ancient_silk_road_to_belt_and_road"- })-- # Secondary imperatives (geographic constraints)- if determinant_counts.get("resource_distribution", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "secure_energy_import_routes",- "geographic_driver": "resource_distribution",- "marshall_justification": "energy_resources_distant_from_population_centers",- "urgency": "high"- })-- if determinant_counts.get("agricultural_concentration", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "ensure_food_security_through_diversified_sources",- "geographic_driver": "agricultural_concentration",- "marshall_justification": "limited_arable_land_requires_external_food_sources",- "urgency": "high"- })-- return imperatives--def identify_chinese_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "maritime_patterns": {- "pattern": "coastal_vulnerability_drives_maritime_expansion",- "examples": [- "treasure_fleet_expeditions",- "maritime_silk_road_development",- "modern_blue_water_navy_building"- ],- "geographic_determinism": True- },-- "infrastructure_patterns": {- "pattern": "geographic_unity_challenges_drive_infrastructure_investment",- "examples": [- "grand_canal_construction",- "great_wall_building",- "modern_belt_and_road_initiative"- ],- "geographic_determinism": True- },-- "security_patterns": {- "pattern": "historical_vulnerability_shapes_security_strategy",- "examples": [- "tributary_system_creation",- "buffer_state_establishment",- "modern_security_bubble_concept"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("maritime_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("infrastructure_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("security_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_chinese_behavior(analysis_results: List[Dict], geographic_prisons: Dict) -> List[Dict]:- """- Predict Chinese behavior based on geographic constraints (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_constraints = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_constraints.add(determinant)-- # Predict behaviors based on active geographic constraints-- if "coastal_vulnerability" in active_constraints:- predictions.append({- "prediction": "continued_maritime_bubble_expansion_in_south_china_sea",- "geographic_driver": "coastal_vulnerability",- "marshall_justification": "historical_maritime_vulnerability_drives_security_expansion",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "unity_challenge" in active_constraints:- predictions.append({- "prediction": "accelerated_infrastructure_connectivity_projects",- "geographic_driver": "unity_challenge",- "marshall_justification": "geographic_barriers_require_infrastructure_solutions",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "resource_distribution" in active_constraints:- predictions.append({- "prediction": "diversified_energy_import_route_development",- "geographic_driver": "resource_distribution",- "marshall_justification": "energy_resources_distant_from_population_centers",- "confidence": 0.7,- "timeframe": "long_term (5-10 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_prisons: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_prisons: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic constraints are driving this event?- - How do these constraints limit China's strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 9fd09c25e..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-EUROPE GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 8+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - European geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="europe"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: Europe is shaped by geography - multiple natural harbors create maritime-power, navigable rivers enable trade, flat plains facilitate invasion, and proximity creates-perpetual competition leading to both conflict and cooperation.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def europe_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- EUROPE GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: European politics is SHAPED by geographic features:- 1. Multiple natural harbors → maritime power development- 2. Navigable rivers → trade, cultural exchange, invasion routes- 3. Flat plains → perpetual invasion vulnerability- 4. Geographic proximity → constant competition and cooperation-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "europe_geography_agent"- print(f"🏔️ Europe Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Europe's Geographic Features (Marshall's Framework)- european_geographic_features = {- "natural_harbors": {- "feature": "Numerous natural deep-water harbors",- "maritime_advantage": "Naval power development, global trade",- "strategic_imperative": "Maritime commerce and naval strength",- "current_implications": "Global shipping trade, naval alliances"+ # 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"},-- "navigable_rivers": {- "feature": "Extensive network of navigable rivers",- "trade_advantage": "Internal trade, cultural exchange, invasion routes",- "strategic_imperative": "River control and trade dominance",- "current_implications": "EU internal trade, Rhine, Danube commerce"+ "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"},-- "flat_plains": {- "feature": "North European Plain and other flat areas",- "invasion_vulnerability": "Easy invasion routes across continent",- "strategic_imperative": "Defense alliances and buffer zones",- "current_implications": "NATO, EU security cooperation"+ "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"},-- "geographic_proximity": {- "feature": "Relatively small continent with close nations",- "competition_driver": "Constant interaction, competition, and cooperation",- "strategic_imperative": "Balance of power and alliance systems",- "current_implications": "EU integration, NATO expansion"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, european_geographic_features- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_european_strategic_imperatives(- geographic_analysis, european_geographic_features- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_european_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "europe",- "timestamp": datetime.now().isoformat(),-- # Geographic feature analysis- "geographic_features": european_geographic_features,- "feature_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic features- "geographic_predictions": predict_european_behavior(- geographic_analysis, european_geographic_features- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, european_geographic_features),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, european_geographic_features)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Europe Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_features: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "feature_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Natural harbors analysis- harbor_keywords = ["maritime", "naval", "shipping", "trade", "port", "coastal"]- if any(keyword in event_title or keyword in event_description for keyword in harbor_keywords):- analysis["geographic_determinants"].append("natural_harbors")- analysis["feature_drivers"].append("maritime_advantage_from_natural_ports")- analysis["strategic_imperatives"].append("naval_power_and_trade_dominance")- analysis["marshall_determinism_score"] += 0.25-- # Navigable rivers analysis- river_keywords = ["river", "rhine", "danube", "trade", "inland", "waterway"]- if any(keyword in event_title or keyword in event_description for keyword in river_keywords):- analysis["geographic_determinants"].append("navigable_rivers")- analysis["feature_drivers"].append("internal_connectivity_through_rivers")- analysis["strategic_imperatives"].append("trade_route_control_and_integration")- analysis["marshall_determinism_score"] += 0.25-- # Flat plains analysis- plain_keywords = ["invasion", "security", "defense", "nato", "plain", "eastern"]- if any(keyword in event_title or keyword in event_description for keyword in plain_keywords):- analysis["geographic_determinants"].append("flat_plains")- analysis["feature_drivers"].append("invasion_vulnerability_from_flat_terrain")- analysis["strategic_imperatives"].append("collective_security_and_alliance_systems")- analysis["marshall_determinism_score"] += 0.25-- # Geographic proximity analysis- proximity_keywords = ["eu", "european union", "cooperation", "integration", "alliance", "brexit"]- if any(keyword in event_title or keyword in event_description for keyword in proximity_keywords):- analysis["geographic_determinants"].append("geographic_proximity")- analysis["feature_drivers"].append("constant_interaction_from_close_proximity")- analysis["strategic_imperatives"].append("balance_of_power_and_integration")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_european_strategic_imperatives(analysis_results: List[Dict], geographic_features: Dict) -> Dict:- """- Calculate European strategic imperatives based on geographic features (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("flat_plains", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_collective_security_through_alliances",- "geographic_driver": "flat_plains",- "marshall_justification": "invasion_vulnerability_requires_collective_defense",- "urgency": "critical",- "historical_continuity": "napoleonic_wars_to_nato"- })-- if determinant_counts.get("geographic_proximity", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "balance_cooperation_and_competition_with_neighbors",- "geographic_driver": "geographic_proximity",- "marshall_justification": "close_proximity_forces_constant_interaction",- "urgency": "critical",- "historical_continuity": "concert_of_europe_to_european_union"- })-- # Secondary imperatives (geographic features)- if determinant_counts.get("natural_harbors", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "maintain_maritime_trade_and_naval_capability",- "geographic_driver": "natural_harbors",- "marshall_justification": "natural_ports_enable_maritime_power",- "urgency": "high"- })-- if determinant_counts.get("navigable_rivers", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "preserve_internal_trade_connectivity",- "geographic_driver": "navigable_rivers",- "marshall_justification": "rivers_enable_internal_integration",- "urgency": "medium"- })-- return imperatives--def identify_european_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "conflict_patterns": {- "pattern": "geographic_proximity_and_flat_plains_drive_perpetual_conflict",- "examples": [- "hundred_years_war",- "napoleonic_wars",- "world_wars_originating_in_europe"- ],- "geographic_determinism": True- },-- "cooperation_patterns": {- "pattern": "geographic_constraints_drive_cooperation_and_integration",- "examples": [- "holy_romanic_empire",- "european_coal_and_steel_community",- "european_union_formation"- ],- "geographic_determinism": True- },-- "maritime_patterns": {- "pattern": "natural_harbors_enable_global_maritime_power",- "examples": [- "age_of_exploration",- "colonial_empires",- "global_trade_dominance"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("conflict_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("cooperation_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("maritime_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_european_behavior(analysis_results: List[Dict], geographic_features: Dict) -> List[Dict]:- """- Predict European behavior based on geographic features (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_features = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_features.add(determinant)-- # Predict behaviors based on active geographic features-- if "flat_plains" in active_features:- predictions.append({- "prediction": "continued_security_cooperation_through_collective_defense",- "geographic_driver": "flat_plains",- "marshall_justification": "invasion_vulnerability_requires_alliance_systems",- "confidence": 0.8,- "timeframe": "ongoing"- })-- if "geographic_proximity" in active_features:- predictions.append({- "prediction": "continued_economic_integration_with_periodic_tensions",- "geographic_driver": "geographic_proximity",- "marshall_justification": "close_proximity_drives_both_cooperation_and_competition",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "natural_harbors" in active_features:- predictions.append({- "prediction": "maintained_global_maritime_trade_influence",- "geographic_driver": "natural_harbors",- "marshall_justification": "natural_ports_enable_continued_maritime_power",- "confidence": 0.7,- "timeframe": "long_term (5-10 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_features: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_features: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic features are driving this event?- - How do these features shape European strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 7ed0979b3..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-INDIA & PAKISTAN GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 7+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - India & Pakistan geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="india_pakistan"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: India & Pakistan are prisoners of geography - Himalayan Mountains create-natural barriers, Indus River water creates conflict, monsoon patterns determine agriculture,-and population density creates internal pressures and external expansion needs.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def india_pakistan_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- INDIA & PAKISTAN GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: India & Pakistan politics is DETERMINED by geographic constraints:- 1. Himalayan Mountains → natural northern barriers, strategic choke points- 2. Indus River System → water resource conflicts, agricultural dependence- 3. Monsoon Patterns → agricultural success/failure, economic stability- 4. Population Density → internal pressures, territorial expansion imperatives-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "india_pakistan_geography_agent"- print(f"🏔️ India & Pakistan Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # India & Pakistan's Geographic Constraints (Marshall's Framework)- subcontinental_geographic_constraints = {- "himalayan_mountains": {- "constraint": "Massive northern mountain barrier",- "strategic_effect": "Natural defense, border security, China access limitation",- "strategic_imperative": "Mountain border control and high-altitude warfare capability",- "current_implications": "Indo-Pak conflicts, India-China tensions, Kashmir disputes"+ # 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"},-- "indus_river_system": {- "constraint": "Shared water resources creating dependency",- "conflict_driver": "Water scarcity, agricultural dependence, dam construction",- "strategic_imperative": "Water resource control and security",- "current_implications": "Indus Water Treaty, water disputes, agricultural security"+ "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"},-- "monsoon_patterns": {- "constraint": "Seasonal rainfall determining agricultural success",- "economic_vulnerability": "Monsoon failure creates economic crisis",- "strategic_imperative": "Water management and agricultural resilience",- "current_implications": "Economic planning, food security, climate adaptation"+ "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"},-- "population_density": {- "constraint": "High population concentration in limited areas",- "pressure_source": "Resource competition, internal political pressures",- "strategic_imperative": "Territorial control and resource acquisition",- "current_implications": "Internal politics, external territorial claims, regional competition"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, subcontinental_geographic_constraints- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_subcontinental_strategic_imperatives(- geographic_analysis, subcontinental_geographic_constraints- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_subcontinental_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "india_pakistan",- "timestamp": datetime.now().isoformat(),-- # Geographic constraint analysis- "geographic_constraints": subcontinental_geographic_constraints,- "constraint_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic constraints- "geographic_predictions": predict_subcontinental_behavior(- geographic_analysis, subcontinental_geographic_constraints- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, subcontinental_geographic_constraints),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, subcontinental_geographic_constraints)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in India & Pakistan Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_constraints: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "constraint_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Himalayan Mountains analysis- himalayan_keywords = ["kashmir", "himalaya", "mountain", "border", "china", "ladakh", "siachen"]- if any(keyword in event_title or keyword in event_description for keyword in himalayan_keywords):- analysis["geographic_determinants"].append("himalayan_mountains")- analysis["constraint_drivers"].append("mountain_barrier_natural_defense_border_dispute")- analysis["strategic_imperatives"].append("mountain_border_control_high_altitude_capability")- analysis["marshall_determinism_score"] += 0.25-- # Indus River System analysis- river_keywords = ["indus", "water", "river", "dam", "irrigation", "indus_water_treaty", "agriculture"]- if any(keyword in event_title or keyword in event_description for keyword in river_keywords):- analysis["geographic_determinants"].append("indus_river_system")- analysis["constraint_drivers"].append("shared_water_resource_conflict_driver")- analysis["strategic_imperatives"].append("water_resource_control_security")- analysis["marshall_determinism_score"] += 0.25-- # Monsoon Patterns analysis- monsoon_keywords = ["monsoon", "rainfall", "drought", "agriculture", "flood", "climate", "food_security"]- if any(keyword in event_title or keyword in event_description for keyword in monsoon_keywords):- analysis["geographic_determinants"].append("monsoon_patterns")- analysis["constraint_drivers"].append("seasonal_rainfall_agricultural_vulnerability")- analysis["strategic_imperatives"].append("water_management_agricultural_resilience")- analysis["marshall_determinism_score"] += 0.25-- # Population Density analysis- population_keywords = ["population", "demographics", "migration", "urban", "resource", "internal_pressure"]- if any(keyword in event_title or keyword in event_description for keyword in population_keywords):- analysis["geographic_determinants"].append("population_density")- analysis["constraint_drivers"].append("high_population_resource_competition_pressure")- analysis["strategic_imperatives"].append("territorial_control_resource_acquisition")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_subcontinental_strategic_imperatives(analysis_results: List[Dict], geographic_constraints: Dict) -> Dict:- """- Calculate India & Pakistan strategic imperatives based on geographic constraints (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("himalayan_mountains", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_mountain_border_control_and_strategic_depth",- "geographic_driver": "himalayan_mountains",- "marshall_justification": "mountain_barriers_require_strategic_choke_point_control",- "urgency": "critical",- "historical_continuity": "british_india_to_modern_border_conflicts"- })-- if determinant_counts.get("indus_river_system", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "secure_water_resource_control_for_agricultural_survival",- "geographic_driver": "indus_river_system",- "marshall_justification": "shared_water_resources_create_zero_sum_competition",- "urgency": "critical",- "historical_continuity": "indus_valley_civilization_to_modern_water_treaties"- })-- # Secondary imperatives (geographic constraints)- if determinant_counts.get("monsoon_patterns", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "develop_water_management_for_monsoon_resilience",- "geographic_driver": "monsoon_patterns",- "marshall_justification": "monsoon_dependence_requires_water_security_infrastructure",- "urgency": "high"- })-- if determinant_counts.get("population_density", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "manage_population_pressure_through_territorial_control",- "geographic_driver": "population_density",- "marshall_justification": "high_density_population_requires_resource_acquisition",- "urgency": "high"- })-- return imperatives--def identify_subcontinental_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "border_patterns": {- "pattern": "mountain_and_river_boundaries_create_perpetual_conflict",- "examples": [- "kashmir_dispute_origin",- "indus_partition_water_conflicts",- "himachal_border_clashes"- ],- "geographic_determinism": True- },-- "water_patterns": {- "pattern": "shared_river_systems_drive_water_conflict_cooperation_cycles",- "examples": [- "indus_valley_water_wars",- "post_partition_water_sharing",- "modern_dam_competition"- ],- "geographic_determinism": True- },-- "population_patterns": {- "pattern": "population_density_drives_territorial_expansion_needs",- "examples": [- "historical_indian_subcontinent_expansion",- "partition_population_exchanges",- "modern_cross_border_migration"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("border_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("water_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("population_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_subcontinental_behavior(analysis_results: List[Dict], geographic_constraints: Dict) -> List[Dict]:- """- Predict India & Pakistan behavior based on geographic constraints (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_constraints = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_constraints.add(determinant)-- # Predict behaviors based on active geographic constraints-- if "himalayan_mountains" in active_constraints:- predictions.append({- "prediction": "continued_kashmir_and_border_conflicts_over_strategic_positions",- "geographic_driver": "himalayan_mountains",- "marshall_justification": "mountain_barriers_create_strategic_choke_point_competition",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "indus_river_system" in active_constraints:- predictions.append({- "prediction": "intensified_water_conflicts_as_dam_construction_continues",- "geographic_driver": "indus_river_system",- "marshall_justification": "shared_water_resources_create_zero_sum_competition",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "monsoon_patterns" in active_constraints:- predictions.append({- "prediction": "increased_water_storage_and_climate_adaptation_investment",- "geographic_driver": "monsoon_patterns",- "marshall_justification": "monsoon_vulnerability_requires_resilience_infrastructure",- "confidence": 0.7,- "timeframe": "long_term (5-10 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_constraints: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_constraints: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic constraints are driving this event?- - How do these constraints limit India & Pakistan strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 4a7bcd212..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-JAPAN & KOREA GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 9+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Japan & Korea geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="japan_korea"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: Japan & Korea are shaped by geography - island nations create security-and isolation, lack of resources drives expansion, mountainous terrain limits agriculture,-and proximity to China creates perpetual strategic tension.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def japan_korea_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- JAPAN & KOREA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Japan & Korea politics is SHAPED by geographic features:- 1. Island Geography → natural security, historical isolation, maritime focus- 2. Resource Scarcity → import dependence, economic efficiency drive, expansion needs- 3. Mountainous Terrain → population concentration, limited agriculture- 4. China Proximity → perpetual strategic tension, security alliance needs-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "japan_korea_geography_agent"- print(f"🏔️ Japan & Korea Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Japan & Korea's Geographic Features (Marshall's Framework)- east_asian_geographic_features = {- "island_geography": {- "feature": "Island nations with natural maritime boundaries",- "security_advantage": "Natural defense against invasion, naval power development",- "strategic_imperative": "Maritime security and trade route protection",- "current_implications": "US alliances, naval capabilities, trade dependence"+ # 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"},-- "resource_scarcity": {- "feature": "Lack of natural resources requiring imports",- "economic_constraint": "Energy and raw material import dependence",- "strategic_imperative": "Economic efficiency and resource security",- "current_implications": "Trade partnerships, energy diversification, technology focus"+ "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"},-- "mountainous_terrain": {- "feature": "Mountains limiting habitable and agricultural land",- "population_constraint": "Population concentration in coastal plains",- "strategic_imperative": "High-density urban development and efficiency",- "current_implications": "Urbanization, limited agriculture, high population density"+ "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"},-- "china_proximity": {- "feature": "Geographic proximity to dominant regional power",- "security_constraint": "Perpetual strategic tension and security needs",- "strategic_imperative": "Alliance maintenance and strategic hedging",- "current_implications": "US security alliances, China trade dependency, strategic balancing"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, east_asian_geographic_features- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_east_asian_strategic_imperatives(- geographic_analysis, east_asian_geographic_features- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_east_asian_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "japan_korea",- "timestamp": datetime.now().isoformat(),-- # Geographic feature analysis- "geographic_features": east_asian_geographic_features,- "feature_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic features- "geographic_predictions": predict_east_asian_behavior(- geographic_analysis, east_asian_geographic_features- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, east_asian_geographic_features),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, east_asian_geographic_features)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Japan & Korea Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_features: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "feature_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Island Geography analysis- island_keywords = ["island", "maritime", "naval", "sea", "coastal", "trade", "shipping"]- if any(keyword in event_title or keyword in event_description for keyword in island_keywords):- analysis["geographic_determinants"].append("island_geography")- analysis["feature_drivers"].append("natural_maritime_boundaries_security_advantage")- analysis["strategic_imperatives"].append("maritime_security_trade_route_protection")- analysis["marshall_determinism_score"] += 0.25-- # Resource Scarcity analysis- resource_keywords = ["energy", "oil", "gas", "import", "resource", "technology", "efficiency"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("resource_scarcity")- analysis["feature_drivers"].append("resource_lack_import_dependence_constraint")- analysis["strategic_imperatives"].append("economic_efficiency_resource_security")- analysis["marshall_determinism_score"] += 0.25-- # Mountainous Terrain analysis- terrain_keywords = ["mountain", "urban", "population", "density", "land", "agriculture", "space"]- if any(keyword in event_title or keyword in event_description for keyword in terrain_keywords):- analysis["geographic_determinants"].append("mountainous_terrain")- analysis["feature_drivers"].append("mountains_limit_habitable_agricultural_land")- analysis["strategic_imperatives"].append("high_density_urban_efficiency")- analysis["marshall_determinism_score"] += 0.25-- # China Proximity analysis- china_keywords = ["china", "beijing", "regional", "alliance", "security", "tension", "balance"]- if any(keyword in event_title or keyword in event_description for keyword in china_keywords):- analysis["geographic_determinants"].append("china_proximity")- analysis["feature_drivers"].append("geographic_proximity_dominant_regional_power_tension")- analysis["strategic_imperatives"].append("alliance_maintenance_strategic_hedging")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_east_asian_strategic_imperatives(analysis_results: List[Dict], geographic_features: Dict) -> Dict:- """- Calculate Japan & Korea strategic imperatives based on geographic features (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("island_geography", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_maritime_security_and_trade_route_protection",- "geographic_driver": "island_geography",- "marshall_justification": "island_nation_status_requires_maritime_focus",- "urgency": "critical",- "historical_continuity": "tokugawa_isolation_to_modern_maritime_power"- })-- if determinant_counts.get("resource_scarcity", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "ensure_resource_security_through_economic_efficiency",- "geographic_driver": "resource_scarcity",- "marshall_justification": "resource_lack_forces_import_dependence_efficiency",- "urgency": "critical",- "historical_continuity": "meiji_modernization_to_current_technology_focus"- })-- # Secondary imperatives (geographic features)- if determinant_counts.get("china_proximity", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "balance_china_proximity_with_security_alliances",- "geographic_driver": "china_proximity",- "marshall_justification": "geographic_proximity_requires_strategic_hedging",- "urgency": "high"- })-- if determinant_counts.get("mountainous_terrain", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "develop_high_density_urban_efficiency",- "geographic_driver": "mountainous_terrain",- "marshall_justification": "limited_flat_land_requires_efficient_use",- "urgency": "medium"- })-- return imperatives--def identify_east_asian_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "isolation_patterns": {- "pattern": "island_geography_drives_historical_isolation_and_opening_cycles",- "examples": [- "tokugawa_isolation_period",- "meiji_restoration_opening",- "modern_global_engagement"- ],- "geographic_determinism": True- },-- "economic_patterns": {- "pattern": "resource_scarcity_drives_economic_efficiency_and_technology_focus",- "examples": [- "meiji_industrialization",- "post_war_economic_miracle",- "modern_technology_leadership"- ],- "geographic_determinism": True- },-- "security_patterns": {- "pattern": "geographic_vulnerability_drives_alliance_formation_and_maritime_development",- "examples": [- "anglo_japanese_alliance",- "post_war_us_security_pact",- "modern_maritime_self_defense"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("isolation_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("economic_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("security_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_east_asian_behavior(analysis_results: List[Dict], geographic_features: Dict) -> List[Dict]:- """- Predict Japan & Korea behavior based on geographic features (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_features = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_features.add(determinant)-- # Predict behaviors based on active geographic features-- if "resource_scarcity" in active_features:- predictions.append({- "prediction": "continued_technology_innovation_and_economic_efficiency_focus",- "geographic_driver": "resource_scarcity",- "marshall_justification": "resource_lack_forces_technological_solutions",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "island_geography" in active_features:- predictions.append({- "prediction": "maintained_maritime_security_capability_and_trade_focus",- "geographic_driver": "island_geography",- "marshall_justification": "island_status_requires_maritime_emphasis",- "confidence": 0.8,- "timeframe": "long_term (5-10 years)"- })-- if "china_proximity" in active_features:- predictions.append({- "prediction": "strategic_hedging_between_china_and_us_security_relationships",- "geographic_driver": "china_proximity",- "marshall_justification": "geographic_proximity_requires_balancing_act",- "confidence": 0.8,- "timeframe": "ongoing"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_features: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_features: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic features are driving this event?- - How do these features shape Japan & Korea strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 90c70e1cc..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-LATIN AMERICA GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 4+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Latin American geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="latin_america"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: Latin America is shaped by geography - Andes Mountains create isolation,-Amazon rainforest limits development, Pacific/Atlantic coasts create division, and rich-resources create external interference patterns.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def latin_america_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- LATIN AMERICA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Latin American politics is SHAPED by geographic features:- 1. Andes Mountains → north-south barriers, east-west isolation- 2. Amazon Rainforest → development limitations, population concentration- 3. Dual Coasts → Atlantic vs Pacific divisions, trade orientation challenges- 4. Resource Wealth → external interference, internal inequality-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "latin_america_geography_agent"- print(f"🏔️ Latin America Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Latin America's Geographic Features (Marshall's Framework)- latin_america_geographic_features = {- "andes_mountains": {- "feature": "Massive north-south mountain barrier",- "isolation_effect": "East-west separation, transportation challenges",- "strategic_imperative": "Regional integration overcoming barriers",- "current_implications": "Infrastructure projects, trade barriers"+ # 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"},-- "amazon_rainforest": {- "feature": "Vast tropical rainforest basin",- "development_constraint": "Population concentration in south, resource extraction challenges",- "strategic_imperative": "Balanced development vs environmental protection",- "current_implications": "Deforestation, indigenous rights, resource extraction"+ "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"},-- "dual_coasts": {- "feature": "Both Pacific and Atlantic coastlines",- "division_effect": "Trade orientation differences, cultural separation",- "strategic_imperative": "Overcoming geographic divisions for unity",- "current_implications": "Trade agreements, inter-ocean connectivity"+ "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"},-- "resource_wealth": {- "feature": "Rich natural resources (minerals, oil, agriculture)",- "external_interference": "Historical colonial and modern external influence",- "strategic_imperative": "Resource sovereignty management",- "current_implications": "Nationalization, foreign investment, inequality"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, latin_america_geographic_features- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_latin_american_strategic_imperatives(- geographic_analysis, latin_america_geographic_features- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_latin_american_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "latin_america",- "timestamp": datetime.now().isoformat(),-- # Geographic feature analysis- "geographic_features": latin_america_geographic_features,- "feature_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic features- "geographic_predictions": predict_latin_american_behavior(- geographic_analysis, latin_america_geographic_features- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, latin_america_geographic_features),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, latin_america_geographic_features)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Latin America Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_features: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "feature_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Andes Mountains analysis- andes_keywords = ["andes", "mountain", "infrastructure", "chile", "peru", "ecuador", "bolivia", "colombia"]- if any(keyword in event_title or keyword in event_description for keyword in andes_keywords):- analysis["geographic_determinants"].append("andes_mountains")- analysis["feature_drivers"].append("mountain_barrier_north_south_separation")- analysis["strategic_imperatives"].append("regional_integration_overcoming_barriers")- analysis["marshall_determinism_score"] += 0.25-- # Amazon Rainforest analysis- amazon_keywords = ["amazon", "rainforest", "deforestation", "brazil", "environment", "indigenous"]- if any(keyword in event_title or keyword in event_description for keyword in amazon_keywords):- analysis["geographic_determinants"].append("amazon_rainforest")- analysis["feature_drivers"].append("vast_forest_development_constraints")- analysis["strategic_imperatives"].append("balanced_development_vs_protection")- analysis["marshall_determinism_score"] += 0.25-- # Dual Coasts analysis- coast_keywords = ["pacific", "atlantic", "trade", "port", "chile", "peru", "brazil", "argentina", "panama"]- if any(keyword in event_title or keyword in event_description for keyword in coast_keywords):- analysis["geographic_determinants"].append("dual_coasts")- analysis["feature_drivers"].append("two_ocean_trade_orientation_division")- analysis["strategic_imperatives"].append("overcoming_geographic_divisions")- analysis["marshall_determinism_score"] += 0.25-- # Resource Wealth analysis- resource_keywords = ["oil", "mining", "copper", "lithium", "resource", "commodity", "nationalization"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("resource_wealth")- analysis["feature_drivers"].append("resource_abundance_external_interference_pattern")- analysis["strategic_imperatives"].append("resource_sovereignty_management")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_latin_american_strategic_imperatives(analysis_results: List[Dict], geographic_features: Dict) -> Dict:- """- Calculate Latin American strategic imperatives based on geographic features (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("andes_mountains", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "overcome_mountain_barriers_for_regional_integration",- "geographic_driver": "andes_mountains",- "marshall_justification": "north_south_mountains_create_east_west_isolation",- "urgency": "high",- "historical_continuity": "inca_roads_to_modern_infrastructure"- })-- if determinant_counts.get("resource_wealth", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_resource_sovereignty_against_external_interference",- "geographic_driver": "resource_wealth",- "marshall_justification": "resource_abundance_attracts_external_exploitation",- "urgency": "critical",- "historical_continuity": "colonial_extraction_to_modern_nationalization"- })-- # Secondary imperatives (geographic features)- if determinant_counts.get("amazon_rainforest", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "balance_development_with_environmental_protection",- "geographic_driver": "amazon_rainforest",- "marshall_justification": "vast_forest_constrains_traditional_development",- "urgency": "high"- })-- if determinant_counts.get("dual_coasts", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "create_inter_ocean_connectivity_for_unity",- "geographic_driver": "dual_coasts",- "marshall_justification": "pacific_atlantic_division_requires_connection",- "urgency": "medium"- })-- return imperatives--def identify_latin_american_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "resource_patterns": {- "pattern": "resource_wealth_drives_external_interference_cycles",- "examples": [- "spanish_colonial_extraction",- "banana_republic_exploitation",- "modern_resource_nationalization"- ],- "geographic_determinism": True- },-- "integration_patterns": {- "pattern": "geographic_barriers_drive_integration_attempts",- "examples": [- "simon_bolivar_unity_attempts",- "regional_trade_blocs",- "modern_infrastructure_projects"- ],- "geographic_determinism": True- },-- "development_patterns": {- "pattern": "geographic_constraints_create_development_inequality",- "examples": [- "coastal_vs_interior_development",- "south_concentration_vs_amazon_isolation",- "resource_export_dependence"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("resource_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("integration_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("development_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_latin_american_behavior(analysis_results: List[Dict], geographic_features: Dict) -> List[Dict]:- """- Predict Latin American behavior based on geographic features (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_features = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_features.add(determinant)-- # Predict behaviors based on active geographic features-- if "resource_wealth" in active_features:- predictions.append({- "prediction": "continued_resource_nationalization_and_sovereignty_assertion",- "geographic_driver": "resource_wealth",- "marshall_justification": "resource_abundance_drives_external_interference_resistance",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "andes_mountains" in active_features:- predictions.append({- "prediction": "accelerated_infrastructure_projects_for_regional_integration",- "geographic_driver": "andes_mountains",- "marshall_justification": "mountain_barriers_require_connectivity_investment",- "confidence": 0.7,- "timeframe": "long_term (5-10 years)"- })-- if "amazon_rainforest" in active_features:- predictions.append({- "prediction": "continued_development_vs_environmental_protection_tensions",- "geographic_driver": "amazon_rainforest",- "marshall_justification": "vast_forest_constrains_traditional_development_patterns",- "confidence": 0.9,- "timeframe": "ongoing"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_features: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_features: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic features are driving this event?- - How do these features shape Latin American strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex fea527308..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-MIDDLE EAST GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 6+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Middle East geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="middle_east"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: Middle East is a prisoner of its geography - desert creates population-concentration, oil wealth distorts economies, water scarcity drives conflict, and colonial-borders create artificial states with inherent instability.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def middle_east_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- MIDDLE EAST GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Middle Eastern politics is DETERMINED by geographic constraints:- 1. Desert geography → population concentration, limited agricultural land- 2. Oil resource curse → wealth without economic diversification- 3. Water scarcity → conflict over limited resources- 4. Colonial borders → artificial states with internal divisions-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "middle_east_geography_agent"- print(f"🏔️ Middle East Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Middle East's Geographic Constraints (Marshall's Framework)- middle_east_geographic_prisons = {- "desert_geography": {- "constraint": "Vast deserts with limited habitable areas",- "population_concentration": "People concentrated in valleys, coasts, oases",- "strategic_imperative": "Control of limited habitable zones",- "current_implications": "Urban concentration, agricultural limitations"+ # 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"},-- "oil_resource_curse": {- "constraint": "Massive oil wealth without economic diversification",- "economic_distortion": "Rentier state model, lack of development",- "strategic_imperative": "Oil price stability maintenance",- "current_implications": "Price wars, OPEC dynamics, wealth concentration"+ "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"},-- "water_scarcity": {- "constraint": "Limited water resources in arid climate",- "conflict_driver": "Rivers, aquifers, and water access disputes",- "strategic_imperative": "Water resource security and control",- "current_implications": "Jordan River, Tigris-Euphrates, Nile disputes"+ "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"},-- "colonial_borders": {- "constraint": "Artificial boundaries ignoring ethnic/realities",- "state_instability": "Artificial states with internal divisions",- "strategic_imperative": "Internal security and regime survival",- "current_implications": "Syria, Iraq, Libya, Yemen instability"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, middle_east_geographic_prisons- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_middle_east_strategic_imperatives(- geographic_analysis, middle_east_geographic_prisons- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_middle_east_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "middle_east",- "timestamp": datetime.now().isoformat(),-- # Geographic constraint analysis- "geographic_prisons": middle_east_geographic_prisons,- "constraint_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic constraints- "geographic_predictions": predict_middle_east_behavior(- geographic_analysis, middle_east_geographic_prisons- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, middle_east_geographic_prisons),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, middle_east_geographic_prisons)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Middle East Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_prisons: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "constraint_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # Desert geography analysis- desert_keywords = ["desert", "arid", "population", "urban", "agriculture", "land"]- if any(keyword in event_title or keyword in event_description for keyword in desert_keywords):- analysis["geographic_determinants"].append("desert_geography")- analysis["constraint_drivers"].append("limited_habitable_area_concentration")- analysis["strategic_imperatives"].append("control_of_populated_zones")- analysis["marshall_determinism_score"] += 0.25-- # Oil resource curse analysis- oil_keywords = ["oil", "petroleum", "opec", "energy", "price", "export", "saudi"]- if any(keyword in event_title or keyword in event_description for keyword in oil_keywords):- analysis["geographic_determinants"].append("oil_resource_curse")- analysis["constraint_drivers"].append("resource_wealth_without_diversification")- analysis["strategic_imperatives"].append("oil_price_maintenance")- analysis["marshall_determinism_score"] += 0.25-- # Water scarcity analysis- water_keywords = ["water", "river", "aquifer", "scarce", "irrigation", "tigris", "Euphrates"]- if any(keyword in event_title or keyword in event_description for keyword in water_keywords):- analysis["geographic_determinants"].append("water_scarcity")- analysis["constraint_drivers"].append("limited_water_resource_competition")- analysis["strategic_imperatives"].append("water_security_control")- analysis["marshall_determinism_score"] += 0.25-- # Colonial borders analysis- border_keywords = ["syria", "iraq", "libya", "yemen", "border", "colonial", "artificial"]- if any(keyword in event_title or keyword in event_description for keyword in border_keywords):- analysis["geographic_determinants"].append("colonial_borders")- analysis["constraint_drivers"].append("artificial_state_boundaries")- analysis["strategic_imperatives"].append("regime_survival_internal_security")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_middle_east_strategic_imperatives(analysis_results: List[Dict], geographic_prisons: Dict) -> Dict:- """- Calculate Middle East strategic imperatives based on geographic constraints (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("oil_resource_curse", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_oil_price_stability_and_market_share",- "geographic_driver": "oil_resource_curse",- "marshall_justification": "oil wealth without diversification requires price control",- "urgency": "critical",- "historical_continuity": "oil_discoveries_to_opec_wars"- })-- if determinant_counts.get("water_scarcity", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "secure_water_resource_control_and_access",- "geographic_driver": "water_scarcity",- "marshall_justification": "arid climate makes water zero-sum_resource",- "urgency": "critical",- "historical_continuity": "ancient_water_wars_to_modern_disputes"- })-- # Secondary imperatives (geographic constraints)- if determinant_counts.get("desert_geography", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "control_urban_population_centers",- "geographic_driver": "desert_geography",- "marshall_justification": "limited_habitable_areas_concentrate_power",- "urgency": "high"- })-- if determinant_counts.get("colonial_borders", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "maintain_regime_survival_through_internal_security",- "geographic_driver": "colonial_borders",- "marshall_justification": "artificial_states_create_instability_needing_repression",- "urgency": "high"- })-- return imperatives--def identify_middle_east_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "resource_patterns": {- "pattern": "oil_resource_geography_determines_economic_and_political_structures",- "examples": [- "rentier_state_development",- "opec_formation_and_price_wars",- "resource_cursed_economies"- ],- "geographic_determinism": True- },-- "conflict_patterns": {- "pattern": "water_scarcity_drives_recurring_conflicts",- "examples": [- "ancient_mesopotamian_water_wars",- "modern_river_disputes",- "aquifer_conflicts"- ],- "geographic_determinism": True- },-- "stability_patterns": {- "pattern": "colonial_borders_create_perpetual_instability",- "examples": [- "sykes-picot_artificial_states",- "post-colonial_state_failure",- "modern_separatist_movements"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("resource_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("conflict_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("stability_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_middle_east_behavior(analysis_results: List[Dict], geographic_prisons: Dict) -> List[Dict]:- """- Predict Middle East behavior based on geographic constraints (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_constraints = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_constraints.add(determinant)-- # Predict behaviors based on active geographic constraints-- if "oil_resource_curse" in active_constraints:- predictions.append({- "prediction": "continued_oil_price_volatility_and_market_share_competition",- "geographic_driver": "oil_resource_curse",- "marshall_justification": "resource_dependence_creates_price_sensitivity",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "water_scarcity" in active_constraints:- predictions.append({- "prediction": "intensified_water_resource_conflicts_and_cooperation_attempts",- "geographic_driver": "water_scarcity",- "marshall_justification": "arid_climate_makes_water_zero_sum_resource",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "colonial_borders" in active_constraints:- predictions.append({- "prediction": "continued_state_instability_and_separatist_movements",- "geographic_driver": "colonial_borders",- "marshall_justification": "artificial_boundaries_create_inherent_instability",- "confidence": 0.8,- "timeframe": "long_term (5-10 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- return []--def identify_event_imperative(event: Dict, geographic_prisons: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_constraint_level(event: Dict, geographic_prisons: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ args = parser.parse_args()- Analyze:- - What geographic constraints are driving this event?- - How do these constraints limit Middle Eastern strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 74f3b3785..33be0896f 100644--- 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.py@@ -1,487 +1,114 @@"""-RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - Russian geographic constraint analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="russia"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.jsonMARSHALL THESIS: Russia is a prisoner of its geography - the North European Plain'svulnerability forces expansion, warm-water port obsession drives foreign policy,and vast territory creates perpetual security challenges."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def russia_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- RUSSIA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: Russian foreign policy is DETERMINED by geographic constraints:- 1. North European Plain vulnerability → perpetual security dilemma- 2. Warm-water port obsession → expansion into Black Sea, Baltic, Pacific- 3. Vast territory → logistical challenges, resource concentration issues- 4. Climate limitations → agricultural constraints, population distribution-- MARSHALL COMPLIANCE REQUIREMENT: Geographic determinism, not policy choice+ 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"""- agent_name = "russia_geography_agent"- print(f"🏔️ Russia Geography Agent - Analyzing events through Marshall's geographic determinism lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # Russia's Geographic Constraints (Marshall's Framework)- russian_geographic_prisons = {+ # 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, Arctic development"+ "current_implications": "Crimea annexation, Syria presence"},-"vast_territory": {"constraint": "17 million km², 11 time zones",- "logistical_challenges": "Infrastructure costs, population distribution",+ "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, food import dependence"+ "current_implications": "Southern expansion"}}- # Analyze events through geographic determinism lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, russian_geographic_prisons- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_russian_strategic_imperatives(- geographic_analysis, russian_geographic_prisons- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_russian_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "russia",- "timestamp": datetime.now().isoformat(),-- # Geographic constraint analysis- "geographic_prisons": russian_geographic_prisons,- "constraint_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic determinism evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "determinism_focus": geographic_determinism_score(geographic_analysis),-- # Predictive analysis based on geographic constraints- "geographic_predictions": predict_russian_behavior(- geographic_analysis, russian_geographic_prisons- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_determinants": extract_geographic_determinants(event),- "strategic_imperative": identify_event_imperative(event, russian_geographic_prisons),- "historical_pattern": match_historical_pattern(event),- "constraint_level": assess_constraint_level(event, russian_geographic_prisons)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic determinism focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in Russia Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_prisons: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic determinism framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_determinants": [],- "constraint_drivers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_determinism_score": 0.0- }-- # North European Plain vulnerability analysis- plain_keywords = ["europe", "nato", "ukraine", "poland", "baltic", "belarus", "expansion"]- if any(keyword in event_title or keyword in event_description for keyword in plain_keywords):- analysis["geographic_determinants"].append("north_european_plain_vulnerability")- analysis["constraint_drivers"].append("perceived_encirclement_from_plain")- analysis["strategic_imperatives"].append("buffer_state_maintenance")- analysis["marshall_determinism_score"] += 0.25-- # Warm-water port obsession analysis- port_keywords = ["crimea", "black sea", "baltic", "pacific", "naval", "port", "syria", "tartus"]- if any(keyword in event_title or keyword in event_description for keyword in port_keywords):- analysis["geographic_determinants"].append("warm_water_port_obsession")- analysis["constraint_drivers"].append("year_round_naval_access_requirement")- analysis["strategic_imperatives"].append("maritime_projection_capability")- analysis["marshall_determinism_score"] += 0.25-- # Vast territory/transportation analysis- territory_keywords = ["rail", "pipeline", "infrastructure", "siberia", "arctic", "transport"]- if any(keyword in event_title or keyword in event_description for keyword in territory_keywords):- analysis["geographic_determinants"].append("vast_territory_challenge")- analysis["constraint_drivers"].append("territorial_control_requirements")- analysis["strategic_imperatives"].append("transport_corridor_dominance")- analysis["marshall_determinism_score"] += 0.25-- # Agriculture/resources analysis- resource_keywords = ["grain", "agriculture", "ukraine", "food", "resources", "energy"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_determinants"].append("agricultural_constraint")- analysis["constraint_drivers"].append("food_security_vulnerability")- analysis["strategic_imperatives"].append("resource_hearth_control")- analysis["marshall_determinism_score"] += 0.25-- return analysis--def calculate_russian_strategic_imperatives(analysis_results: List[Dict], geographic_prisons: Dict) -> Dict:- """- Calculate Russia's strategic imperatives based on geographic constraints (Marshall's core thesis)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_drivers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic determinants across events- determinant_counts = {}- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- determinant_counts[determinant] = determinant_counts.get(determinant, 0) + 1-- # Primary imperatives (Marshall's core geographic determinants)- if determinant_counts.get("north_european_plain_vulnerability", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_buffer_zones_in_eastern_europe",- "geographic_driver": "north_european_plain_vulnerability",- "marshall_justification": "flat_invasion_route_requires_buffer_states",- "urgency": "critical",- "historical_continuity": "napoleonic_wars_to_nato_expansion"- })-- if determinant_counts.get("warm_water_port_obsession", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "secure_year_round_naval_access",- "geographic_driver": "warm_water_port_obsession",- "marshall_justification": "ice_bound_ports_require_warm_water_alternatives",- "urgency": "critical",- "historical_continuity": "peter_the_great_to_present_day"- })-- # Secondary imperatives (geographic constraints)- if determinant_counts.get("vast_territory_challenge", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "control_transport_corridors",- "geographic_driver": "vast_territory_challenge",- "marshall_justification": "territorial_size_requires_infrastructure_control",- "urgency": "high"- })+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- if determinant_counts.get("agricultural_constraint", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "secure_agricultural_heartland",- "geographic_driver": "agricultural_constraint",- "marshall_justification": "limited_arable_land_requires_food_security",- "urgency": "high"- })+ 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()}- return imperatives+Query: {query}-def identify_russian_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic determinism (Marshall requirement)- """-- patterns = {- "expansion_patterns": {- "pattern": "territorial_expansion_follows_geographic_constraints",- "examples": [- "southward_expansion_for_warm_water_ports",- "westward_expansion_for_plain_security",- "eastward_expansion_for_resources_and_security"- ],- "geographic_determinism": True- },-- "security_patterns": {- "pattern": "perpetual_security_dilemma_from_geographic_vulnerability",- "examples": [- "north_european_plain_invasions",- "buffer_state_creation",- "defensive_depth_strategy"- ],- "geographic_determinism": True- },-- "economic_patterns": {- "pattern": "economic_strategy_driven_by_geographic_constraints",- "examples": [- "energy_politics_from_resource_distribution",- "infrastructure_investment_from_territorial_challenge",- "agricultural_importance_from_climate_limitations"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_determinism_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "constraint_over_choice_emphasis": 0.0 # 10% weight- }-- # Geographic determinism focus (40%)- total_events = len(analysis_results)- if total_events > 0:- determinism_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_determinism_score", 0) > 0.5)- scores["geographic_determinism_focus"] = (determinism_events / total_events) * 0.4-- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("expansion_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("security_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("economic_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score-- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Constraint over choice emphasis (10%)- # Check if analysis emphasizes geographic constraints over policy choices- constraint_emphasis = sum(analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["constraint_over_choice_emphasis"] = min(constraint_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_determinism_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic determinism- """- if not analysis_results:- return 0.0-- determinism_scores = [analysis.get("marshall_determinism_score", 0)- for analysis in analysis_results]- return sum(determinism_scores) / len(determinism_scores)--def predict_russian_behavior(analysis_results: List[Dict], geographic_prisons: Dict) -> List[Dict]:- """- Predict Russian behavior based on geographic constraints (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic drivers- active_constraints = set()- for analysis in analysis_results:- for determinant in analysis.get("geographic_determinants", []):- active_constraints.add(determinant)-- # Predict behaviors based on active geographic constraints-- if "north_european_plain_vulnerability" in active_constraints:- predictions.append({- "prediction": "continued_buffer_zone_maintenance_in_eastern_europe",- "geographic_driver": "north_european_plain_vulnerability",- "marshall_justification": "geographic_vulnerability_drives_security_policy",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "warm_water_port_obsession" in active_constraints:- predictions.append({- "prediction": "intensified_efforts_to_secure_mediterranean_persence",- "geographic_driver": "warm_water_port_obsession",- "marshall_justification": "ice_bound_ports_create_year_round_naval_need",- "confidence": 0.7,- "timeframe": "short_term (1-2 years)"- })-- if "vast_territory_challenge" in active_constraints:- predictions.append({- "prediction": "increased_focus_on_arctic_transport_corridors",- "geographic_driver": "vast_territory_challenge",- "marshall_justification": "territorial_size_requires_transport_control",- "confidence": 0.6,- "timeframe": "long_term (5-10 years)"- })-- return predictions--def extract_geographic_determinants(event: Dict) -> List[str]:- """Extract geographic determinants from event"""- # Implementation would analyze event for geographic factors- return []--def identify_event_imperative(event: Dict, geographic_prisons: Dict) -> str:- """Identify strategic imperative driving event"""- # Implementation would map event to geographic imperative- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- # Implementation would identify historical continuity- return ""--def assess_constraint_level(event: Dict, geographic_prisons: Dict) -> float:- """Assess how strongly geographic constraints drive event"""- # Implementation would calculate constraint influence level- return 0.0+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic determinism understanding- """+ 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)- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:- Event: {event_data}- Framework: {framework}+def main():+ """CLI entry point for testing"""+ import argparse- MARSHALL THESIS REQUIREMENTS:- 1. Geographic DETERMINISM (not just influence) - geography forces specific behaviors- 2. Historical pattern recognition - recurring behaviors from geographic constraints- 3. Strategic imperative identification - must-have policies driven by geography- 4. Constraint over choice - geographic limitations determine policy options+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- Analyze:- - What geographic constraints are driving this event?- - How do these constraints limit Russia's strategic choices?- - What historical patterns does this event follow?- - What strategic imperatives are being fulfilled?+ args = parser.parse_args()- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- # Implementation would call OpenAI/Anthropic for enhanced analysis- # This is placeholder for LLM integration- return {- "llm_analysis": "LLM-enhanced geographic determinism analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+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.pyindex 553b4ed8e..33be0896f 100644--- 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.py@@ -1,479 +1,114 @@"""-USA GEOGRAPHY AGENT - Tim Marshall's Framework-Based on "Prisoners of Geography" Chapter 3+RUSSIA GEOGRAPHY AGENT - Tim Marshall's Framework (FinAgent Core)+Based on "Prisoners of Geography" Chapter 1-===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - geographic_data (physical, climate, resources)-# - GEOPOLITICAL_API_KEY-#-# OUTPUT:-# - US geographic advantage analysis-# - Strategic imperative identification-# - Historical pattern recognition-# - Marshall thesis compliance score (70%+ required)-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="marshalls_geographic_determinism"-# - region="usa"+This agent now uses finagent_core for LLM execution.+All configuration is in GeopoliticsAgents/configs/agent_definitions.json-MARSHALL THESIS: USA benefits from geographic advantages - ocean buffers create security,-agricultural abundance creates wealth, and resource independence enables power projection.-Geography ENABLES, rather than constrains, American foreign policy choices.+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."""-from typing import Dict, List, Any, Optional-import json-from datetime import datetime-import requests-import os+import sys+from pathlib import Path+from typing import Dict, Any-# Import base agent classes-from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data+# Add parent directories to path+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))-# Import geographic analysis modules-from ..geographic_modules.geographic_constraints import analyze_physical_constraints-from ..geographic_modules.historical_patterns import identify_historical_patterns-from ..geographic_modules.strategic_imperatives import calculate_strategic_imperatives+from finagent_core.base_agent import AgentRegistry-def usa_geography_agent(state: AgentState) -> Dict[str, Any]:+class RussiaGeographyAgent:"""- USA GEOGRAPHY AGENT - Tim Marshall's Geographic Determinism Framework+ Russia Geography Agent using FinAgent Core- Core Thesis: US foreign policy is ENABLED by geographic advantages:- 1. Ocean buffers → security, power projection capability- 2. Agricultural abundance → wealth, food security, export power- 3. Resource independence → energy security, economic strength- 4. River networks → internal commerce, industrial development-- MARSHALL COMPLIANCE REQUIREMENT: Geographic advantage analysis (unique case)+ 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"""- agent_name = "usa_geography_agent"- print(f"🏔️ USA Geography Agent - Analyzing events through Marshall's geographic advantage lens")+ def __init__(self, config_path: Path = None):+ if config_path is None:+ config_path = Path(__file__).parent.parent.parent / "configs" / "agent_definitions.json"- try:- # Extract current events from state- current_events = state.get('current_events', [])+ registry = AgentRegistry(config_path)+ self.config = registry.get_agent("prisoners_geography_russia")- if not current_events:- print("⚠️ No current events provided for analysis")- return {- "agent": agent_name,- "analysis": "No events to analyze",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }+ if not self.config:+ raise ValueError("Russia geography agent config not found in JSON")- # USA's Geographic Advantages (Marshall's Framework)- us_geographic_advantages = {- "ocean_buffers": {- "advantage": "Atlantic and Pacific protection",- "security_benefit": "Invasion defense, territorial security",- "strategic_imperative": "Power projection capability",- "current_implications": "Global naval presence, intervention capability"+ # 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"},-- "agricultural_abundance": {- "advantage": "Midwest agricultural heartland",- "economic_benefit": "Food security, export wealth",- "strategic_imperative": "Global food system influence",- "current_implications": "Agricultural exports, food diplomacy"+ "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"},-- "resource_independence": {- "advantage": "Domestic energy and mineral resources",- "economic_benefit": "Energy security, industrial independence",- "strategic_imperative": "Economic leverage through resources",- "current_implications": "Energy exports, sanctions power"+ "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"},-- "river_networks": {- "advantage": "Mississippi and connected waterways",- "economic_benefit": "Internal trade, industrial development",- "strategic_imperative": "Economic integration and strength",- "current_implications": "Internal commerce, agricultural transport"+ "climate_agriculture": {+ "constraint": "Only 12% arable land, permafrost",+ "food_security_issue": "Limited agricultural heartland",+ "strategic_imperative": "Ukraine grain belt control",+ "current_implications": "Southern expansion"}}- # Analyze events through geographic advantage lens- geographic_analysis = []-- for event in current_events:- event_analysis = analyze_event_through_geographic_lens(- event, us_geographic_advantages- )- geographic_analysis.append(event_analysis)-- # Calculate strategic imperatives based on current events- strategic_imperatives = calculate_us_strategic_imperatives(- geographic_analysis, us_geographic_advantages- )-- # Identify historical patterns (Marshall requires pattern recognition)- historical_patterns = identify_us_historical_patterns(geographic_analysis)-- # Calculate Marshall thesis compliance score- marshall_compliance = calculate_marshall_compliance(- geographic_analysis, strategic_imperatives, historical_patterns- )-- # Prepare final analysis- analysis_result = {- "agent": agent_name,- "framework": "marshalls_geographic_determinism",- "region": "usa",- "timestamp": datetime.now().isoformat(),-- # Geographic advantage analysis (unique case for US)- "geographic_advantages": us_geographic_advantages,- "advantage_analysis": geographic_analysis,-- # Strategic imperatives (Marshall's core concept)- "strategic_imperatives": strategic_imperatives,-- # Historical patterns (geographic advantage evidence)- "historical_patterns": historical_patterns,-- # Marshall thesis compliance- "marshall_compliance_score": marshall_compliance,- "advantage_focus": geographic_advantage_score(geographic_analysis),-- # Predictive analysis based on geographic advantages- "geographic_predictions": predict_us_behavior(- geographic_analysis, us_geographic_advantages- ),-- # Event-specific analyses- "event_analyses": [- {- "event": event.get("title", "Unknown"),- "geographic_advantages": extract_geographic_advantages(event),- "strategic_imperative": identify_event_imperative(event, us_geographic_advantages),- "historical_pattern": match_historical_pattern(event),- "advantage_level": assess_advantage_level(event, us_geographic_advantages)- }- for event in current_events[:5] # Limit to first 5 events- ]- }-- # Show reasoning (for development/debugging)- show_agent_reasoning(analysis_result, agent_name)-- # Validate Marshall compliance- if marshall_compliance < 0.7:- print(f"⚠️ LOW MARSHALL COMPLIANCE: {marshall_compliance:.2f} (minimum 0.70 required)")- print(" - Geographic advantage focus must be strengthened")- print(" - Historical pattern recognition needs improvement")- print(" - Strategic imperative identification requires enhancement")-- return analysis_result-- except Exception as e:- print(f"❌ Error in USA Geography Agent: {str(e)}")- return {- "agent": agent_name,- "error": str(e),- "analysis": "Geographic analysis failed",- "confidence": 0.0,- "marshall_compliance_score": 0.0- }--def analyze_event_through_geographic_lens(event: Dict, geographic_advantages: Dict) -> Dict:- """- Analyze a specific event through Marshall's geographic advantage framework- """-- event_title = event.get("title", "").lower()- event_description = event.get("description", "").lower()-- analysis = {- "event": event.get("title", "Unknown"),- "geographic_advantages": [],- "advantage_enablers": [],- "strategic_imperatives": [],- "historical_continuity": False,- "marshall_advantage_score": 0.0- }-- # Ocean buffer analysis- ocean_keywords = ["naval", "marine", "ocean", "projection", "global", "intervention"]- if any(keyword in event_title or keyword in event_description for keyword in ocean_keywords):- analysis["geographic_advantages"].append("ocean_buffers")- analysis["advantage_enablers"].append("security_from_ocean_barriers")- analysis["strategic_imperatives"].append("global_power_projection")- analysis["marshall_advantage_score"] += 0.25-- # Agricultural abundance analysis- agriculture_keywords = ["agriculture", "food", "export", "commodity", "farm", "grain"]- if any(keyword in event_title or keyword in event_description for keyword in agriculture_keywords):- analysis["geographic_advantages"].append("agricultural_abundance")- analysis["advantage_enablers"].append("food_security_and_export_wealth")- analysis["strategic_imperatives"].append("global_food_system_influence")- analysis["marshall_advantage_score"] += 0.25-- # Resource independence analysis- resource_keywords = ["energy", "oil", "gas", "shale", "mineral", "resource"]- if any(keyword in event_title or keyword in event_description for keyword in resource_keywords):- analysis["geographic_advantages"].append("resource_independence")- analysis["advantage_enablers"].append("domestic_resource_availability")- analysis["strategic_imperatives"].append("energy_leverage_and_independence")- analysis["marshall_advantage_score"] += 0.25-- # River network analysis- infrastructure_keywords = ["infrastructure", "river", "transport", "internal", "commerce"]- if any(keyword in event_title or keyword in event_description for keyword in infrastructure_keywords):- analysis["geographic_advantages"].append("river_networks")- analysis["advantage_enablers"].append("internal_connectivity_and_trade")- analysis["strategic_imperatives"].append("economic_integration_strength")- analysis["marshall_advantage_score"] += 0.25-- return analysis--def calculate_us_strategic_imperatives(analysis_results: List[Dict], geographic_advantages: Dict) -> Dict:- """- Calculate US strategic imperatives based on geographic advantages (Marshall's framework)- """-- imperatives = {- "primary_imperatives": [],- "secondary_imperatives": [],- "geographic_enablers": [],- "urgency_levels": {},- "historical_continuity": {}- }-- # Analyze frequency of geographic advantages across events- advantage_counts = {}- for analysis in analysis_results:- for advantage in analysis.get("geographic_advantages", []):- advantage_counts[advantage] = advantage_counts.get(advantage, 0) + 1-- # Primary imperatives (Marshall's core geographic advantages)- if advantage_counts.get("ocean_buffers", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "maintain_global_power_projection_capability",- "geographic_enabler": "ocean_buffers",- "marshall_justification": "ocean_security_enables_global_intervention",- "urgency": "critical",- "historical_continuity": "monroe_doctrine_to_present_day"- })-- if advantage_counts.get("agricultural_abundance", 0) > 0:- imperatives["primary_imperatives"].append({- "imperative": "exercise_global_food_system_influence",- "geographic_enabler": "agricultural_abundance",- "marshall_justification": "agricultural_wealth_creates_export_power",- "urgency": "high",- "historical_continuity": "agricultural_exports_to_food_diplomacy"- })-- # Secondary imperatives (geographic advantages)- if advantage_counts.get("resource_independence", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "leverage_energy_independence_for_economic_power",- "geographic_enabler": "resource_independence",- "marshall_justification": "domestic_resources_create_economic_leverage",- "urgency": "high"- })-- if advantage_counts.get("river_networks", 0) > 0:- imperatives["secondary_imperatives"].append({- "imperative": "maintain_internal_economic_integration",- "geographic_enabler": "river_networks",- "marshall_justification": "internal_connectivity_supports_economic_strength",- "urgency": "medium"- })-- return imperatives--def identify_us_historical_patterns(analysis_results: List[Dict]) -> Dict:- """- Identify historical patterns that demonstrate geographic advantages (Marshall requirement)- """-- patterns = {- "expansion_patterns": {- "pattern": "geographic_security_enables_territorial_expansion",- "examples": [- "westward_expansion",- "manifest_destiny_realization",- "hemispheric_dominance_establishment"- ],- "geographic_determinism": True- },-- "power_projection_patterns": {- "pattern": "ocean_security_enables_global_intervention",- "examples": [- "spanish_american_war",- "world_war_participation",- "cold_war_global_containment"- ],- "geographic_determinism": True- },-- "economic_patterns": {- "pattern": "resource_abundance_enables_economic_dominance",- "examples": [- "industrial_revolution_acceleration",- "agricultural_export_development",- "energy_independence_achievement"- ],- "geographic_determinism": True- }- }-- return patterns--def calculate_marshall_compliance(analysis_results: List[Dict], imperatives: Dict, patterns: Dict) -> float:- """- Calculate compliance with Marshall's geographic determinism thesis- Minimum 70% required for valid analysis- """-- scores = {- "geographic_advantage_focus": 0.0, # 40% weight- "historical_pattern_recognition": 0.0, # 30% weight- "strategic_imperative_identification": 0.0, # 20% weight- "advantage_over_constraint_emphasis": 0.0 # 10% weight- }+ def analyze(self, query: str) -> str:+ """+ Analyze query through Marshall's geographic determinism lens- # Geographic advantage focus (40%)- total_events = len(analysis_results)- if total_events > 0:- advantage_events = sum(1 for analysis in analysis_results- if analysis.get("marshall_advantage_score", 0) > 0.5)- scores["geographic_advantage_focus"] = (advantage_events / total_events) * 0.4+ 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()}- # Historical pattern recognition (30%)- pattern_score = 0.0- if patterns.get("expansion_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("power_projection_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- if patterns.get("economic_patterns", {}).get("geographic_determinism"):- pattern_score += 0.1- scores["historical_pattern_recognition"] = pattern_score+Query: {query}- # Strategic imperative identification (20%)- primary_imperatives = len(imperatives.get("primary_imperatives", []))- if primary_imperatives >= 2:- scores["strategic_imperative_identification"] = 0.2- elif primary_imperatives >= 1:- scores["strategic_imperative_identification"] = 0.1-- # Advantage over constraint emphasis (10%)- advantage_emphasis = sum(analysis.get("marshall_advantage_score", 0)- for analysis in analysis_results) / max(total_events, 1)- scores["advantage_over_constraint_emphasis"] = min(advantage_emphasis * 0.1, 0.1)-- total_compliance = sum(scores.values())-- return round(total_compliance, 3)--def geographic_advantage_score(analysis_results: List[Dict]) -> float:- """- Calculate how strongly the analysis emphasizes geographic advantages- """- if not analysis_results:- return 0.0-- advantage_scores = [analysis.get("marshall_advantage_score", 0)- for analysis in analysis_results]- return sum(advantage_scores) / len(advantage_scores)--def predict_us_behavior(analysis_results: List[Dict], geographic_advantages: Dict) -> List[Dict]:- """- Predict US behavior based on geographic advantages (Marshall's predictive framework)- """-- predictions = []-- # Analyze current events to identify geographic advantages- active_advantages = set()- for analysis in analysis_results:- for advantage in analysis.get("geographic_advantages", []):- active_advantages.add(advantage)-- # Predict behaviors based on active geographic advantages-- if "ocean_buffers" in active_advantages:- predictions.append({- "prediction": "continued_global_power_projection_and_intervention_capability",- "geographic_advantage": "ocean_buffers",- "marshall_justification": "ocean_security_enables_global_engagement",- "confidence": 0.9,- "timeframe": "ongoing"- })-- if "agricultural_abundance" in active_advantages:- predictions.append({- "prediction": "increased_use_of_food_diplomacy_and_agricultural_leverage",- "geographic_advantage": "agricultural_abundance",- "marshall_justification": "agricultural_wealth_creates_diplomatic_power",- "confidence": 0.8,- "timeframe": "medium_term (2-5 years)"- })-- if "resource_independence" in active_advantages:- predictions.append({- "prediction": "enhanced_energy_leverage_in_international_relations",- "geographic_advantage": "resource_independence",- "marshall_justification": "energy_independence_creates_economic_leverage",- "confidence": 0.7,- "timeframe": "short_term (1-3 years)"- })-- return predictions--def extract_geographic_advantages(event: Dict) -> List[str]:- """Extract geographic advantages from event"""- return []--def identify_event_imperative(event: Dict, geographic_advantages: Dict) -> str:- """Identify strategic imperative driving event"""- return ""--def match_historical_pattern(event: Dict) -> str:- """Match event to historical pattern"""- return ""+Analyze this through Marshall's framework, connecting to geographic determinism.+"""+ return context-def assess_advantage_level(event: Dict, geographic_advantages: Dict) -> float:- """Assess how strongly geographic advantages enable event"""- return 0.0+ 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)-# Integration with LLM providers for enhanced analysis-def analyze_with_llm(event_data: Dict, framework: str = "marshalls_geographic_determinism") -> Dict:- """- Enhanced analysis using LLM providers for deeper geographic advantage understanding- """- llm_prompt = f"""- Analyze this geopolitical event through Tim Marshall's geographic determinism framework:+def main():+ """CLI entry point for testing"""+ import argparse- Event: {event_data}- Framework: {framework}+ parser = argparse.ArgumentParser(description="Russia Geography Agent")+ parser.add_argument("--query", required=True, help="Query to analyze")- MARSHALL THESIS REQUIREMENTS (US UNIQUE CASE):- 1. Geographic ADVANTAGE (not constraint) - geography enables policy choices- 2. Historical pattern recognition - recurring behaviors enabled by geography- 3. Strategic imperative identification - opportunities created by geography- 4. Advantage over constraint - geographic opportunities determine policy options+ args = parser.parse_args()- Analyze:- - What geographic advantages are enabling this event?- - How do these advantages create US strategic opportunities?- - What historical patterns does this event follow?- - What strategic imperatives are being enabled?+ agent = RussiaGeographyAgent()+ result = agent.analyze(args.query)+ print(result)- Provide analysis that demonstrates 70%+ compliance with Marshall's geographic determinism thesis.- """- return {- "llm_analysis": "LLM-enhanced geographic advantage analysis",- "marshall_compliance": 0.75- }\ No newline at end of file+if __name__ == "__main__":+ main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/run_all_tests.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/run_all_tests.pydeleted file mode 100644index a240bd22f..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/run_all_tests.py+++ /dev/null@@ -1,330 +0,0 @@-"""-Master Test Runner for Prisoners of Geography Agents-Tests all regional agents for Marshall's geographic determinism compliance-"""--import json-import sys-import os-from datetime import datetime--# Add parent directories to path for imports-sys.path.append(os.path.dirname(os.path.dirname(__file__)))--def test_all_geography_agents():- """- Test all implemented Prisoners of Geography agents- Validates Marshall's geographic determinism compliance across all regions- """-- print("🌍 Prisoners of Geography - Master Test Suite")- print("=" * 80)- print("Testing Tim Marshall's Geographic Determinism Framework")- print("Required: 70%+ Marshall thesis compliance for all agents")- print()-- # Define implemented agents- implemented_agents = [- {- "name": "Russia",- "file": "test_russia_geography",- "region": "russia",- "chapter": 1- },- {- "name": "China",- "file": "test_china_geography",- "region": "china",- "chapter": 2- },- {- "name": "USA",- "file": "test_usa_geography",- "region": "usa",- "chapter": 3- },- {- "name": "Middle East",- "file": "test_middle_east_geography",- "region": "middle_east",- "chapter": 6- },- {- "name": "Europe",- "file": "test_europe_geography",- "region": "europe",- "chapter": 8- }- ]-- test_results = {}- overall_success = True-- for agent_info in implemented_agents:- print(f"🧪 Testing {agent_info['name']} Geography Agent (Chapter {agent_info['chapter']})")- print("-" * 60)-- try:- # Import and run individual test- test_module = __import__(agent_info['file'])- test_passed = test_module.test_geography_agent()-- test_results[agent_info['region']] = {- "name": agent_info['name'],- "chapter": agent_info['chapter'],- "passed": test_passed,- "error": None- }-- if test_passed:- print(f"✅ {agent_info['name']} Agent PASSED")- else:- print(f"❌ {agent_info['name']} Agent FAILED")- overall_success = False-- except ImportError as e:- print(f"❌ Import Error for {agent_info['name']}: {e}")- test_results[agent_info['region']] = {- "name": agent_info['name'],- "chapter": agent_info['chapter'],- "passed": False,- "error": f"Import error: {e}"- }- overall_success = False-- except Exception as e:- print(f"❌ Test Error for {agent_info['name']}: {e}")- test_results[agent_info['region']] = {- "name": agent_info['name'],- "chapter": agent_info['chapter'],- "passed": False,- "error": f"Test error: {e}"- }- overall_success = False-- print()-- # Print summary- print("=" * 80)- print("📊 TEST SUMMARY")- print("=" * 80)-- total_agents = len(implemented_agents)- passed_agents = sum(1 for result in test_results.values() if result['passed'])- failed_agents = total_agents - passed_agents-- print(f"Total Agents Tested: {total_agents}")- print(f"Passed: {passed_agents} ✅")- print(f"Failed: {failed_agents} ❌")- print(f"Success Rate: {(passed_agents/total_agents)*100:.1f}%")- print()-- # Detailed results- print("📋 DETAILED RESULTS:")- for region, result in test_results.items():- status = "✅ PASS" if result['passed'] else "❌ FAIL"- print(f" {result['name']} (Chapter {result['chapter']}): {status}")- if result['error']:- print(f" Error: {result['error']}")-- print()-- # Marshall thesis compliance summary- print("🎯 MARSHALL THESIS COMPLIANCE SUMMARY:")- print("Geographic Determinism Framework Validation")-- if overall_success:- print("✅ ALL AGENTS MEET MARSHALL'S GEOGRAPHIC DETERMINISM REQUIREMENTS")- print(" - Geographic constraints drive policy choices")- print(" - Historical patterns demonstrate determinism")- print(" - Strategic imperatives identified correctly")- print(" - 70%+ compliance achieved across all agents")- print()- print("🎉 Prisoners of Geography Agent Framework Ready for Production!")- else:- print("⚠️ SOME AGENTS FAIL MARSHALL COMPLIANCE REQUIREMENTS")- print(" - Review failed agents for geographic determinism focus")- print(" - Strengthen historical pattern recognition")- print(" - Improve strategic imperative identification")- print(" - Ensure 70%+ compliance threshold is met")- print()- print("🔧 Framework requires refinement before production deployment")-- return overall_success--def create_mock_event_data(region):- """- Create mock event data specific to each region for testing- """-- event_templates = {- "russia": [- {- "title": "Russia strengthens Black Sea naval presence",- "description": "Russian fleet movements in response to regional security concerns",- "source": "Naval Intelligence",- "date": "2024-10-15"- },- {- "title": "Arctic shipping route development accelerates",- "description": "Northern Sea Route sees increased traffic as ice melts",- "source": "Arctic Monitor",- "date": "2024-10-10"- }- ],- "china": [- {- "title": "South China Sea militarization continues",- "description": "Island fortification and naval deployments expand",- "source": "Asia Security",- "date": "2024-10-12"- },- {- "title": "Belt and Road infrastructure project completed",- "description": "New railway connection enhances regional connectivity",- "source": "Economic Report",- "date": "2024-10-08"- }- ],- "usa": [- {- "title": "US naval freedom of navigation operation",- "description": "Warship transits disputed waters to assert international law",- "source": "Pentagon Briefing",- "date": "2024-10-14"- },- {- "title": "Agricultural export levels reach new highs",- "description": "American grain exports surge to meet global demand",- "source": "Agriculture Department",- "date": "2024-10-09"- }- ],- "middle_east": [- {- "title": "OPEC discusses oil production quotas",- "description": "Member nations consider output adjustments to stabilize prices",- "source": "Energy Report",- "date": "2024-10-13"- },- {- "title": "Jordan River water sharing agreement disputed",- "description": "Regional tensions rise over scarce water resources",- "source": "Middle East Monitor",- "date": "2024-10-07"- }- ],- "europe": [- {- "title": "EU strengthens eastern border security",- "description": "Defense cooperation enhanced amid regional tensions",- "source": "Brussels Report",- "date": "2024-10-11"- },- {- "title": "Rhine River trade volume increases",- "description": "Internal European commerce shows strong growth",- "source": "EU Economic Report",- "date": "2024-10-06"- }- ]- }-- return event_templates.get(region, [])--def validate_framework_structure():- """- Validate that the Prisoners of Geography framework structure is correct- """-- print("🏗️ FRAMEWORK STRUCTURE VALIDATION")- print("-" * 40)-- required_structure = {- "region_agents": [- "russia_geography_agent.py",- "china_geography_agent.py",- "usa_geography_agent.py",- "middle_east_geography_agent.py",- "europe_geography_agent.py"- ],- "geographic_modules": [- "geographic_constraints.py",- "historical_patterns.py",- "strategic_imperatives.py"- ],- "test_agents": [- "test_russia_geography.py",- "run_all_tests.py"- ]- }-- base_path = os.path.dirname(os.path.dirname(__file__))- structure_valid = True-- for folder, required_files in required_structure.items():- folder_path = os.path.join(base_path, folder)- print(f"📁 Checking {folder}/:")-- if not os.path.exists(folder_path):- print(f" ❌ Folder missing: {folder}")- structure_valid = False- continue-- for file_name in required_files:- file_path = os.path.join(folder_path, file_name)- if os.path.exists(file_path):- print(f" ✅ {file_name}")- else:- print(f" ❌ {file_name} - MISSING")- structure_valid = False-- if structure_valid:- print("\n✅ Framework structure validation PASSED")- else:- print("\n❌ Framework structure validation FAILED")- print(" - Missing files or folders detected")- print(" - Review framework structure before proceeding")-- return structure_valid--def main():- """- Main test runner- """-- print("🚀 Prisoners of Geography - Master Test Suite")- print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")- print()-- # Validate framework structure first- structure_valid = validate_framework_structure()- print()-- if not structure_valid:- print("❌ Framework structure issues detected - aborting tests")- return False-- # Run all agent tests- test_success = test_all_geography_agents()-- # Final result- print("\n" + "=" * 80)- print("🏁 FINAL TEST RESULT")-- if structure_valid and test_success:- print("✅ ALL TESTS PASSED - FRAMEWORK READY FOR PRODUCTION")- print("🌍 Prisoners of Geography agents successfully implement")- print(" Tim Marshall's geographic determinism framework")- return True- else:- print("❌ TESTS FAILED - FRAMEWORK NEEDS REFINEMENT")- if not structure_valid:- print(" - Fix framework structure issues")- if not test_success:- print(" - Improve agent Marshall compliance")- return False--if __name__ == "__main__":- success = main()- sys.exit(0 if success else 1)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/test_russia_geography.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/test_russia_geography.pydeleted file mode 100644index a223f9c06..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/PrisonersOfGeographyAgents/test_agents/test_russia_geography.py+++ /dev/null@@ -1,255 +0,0 @@-"""-Test Framework for Russia Geography Agent-Validates Marshall's geographic determinism compliance-"""--import json-from datetime import datetime-import sys-import os--# Add parent directories to path for imports-sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))--def test_russia_geography_agent():- """- Test Russia Geography Agent with sample events- Validates Marshall's geographic determinism compliance (70%+ required)- """-- print("🧪 Testing Russia Geography Agent - Marshall's Geographic Determinism Framework")- print("=" * 80)-- # Test event data focusing on Russian geographic constraints- test_events = [- {- "title": "Russia strengthens Baltic Sea military presence",- "description": "Russian naval deployments in Baltic Sea increase amid NATO expansion concerns",- "source": "Geopolitical Monitor",- "date": "2024-10-15",- "region": "europe/russia"- },- {- "title": "Ukraine grain export disruption affects global food security",- "description": "Conflict in Ukraine's agricultural heartland impacts worldwide grain supplies",- "source": "Agricultural Report",- "date": "2024-10-10",- "region": "europe/russia"- },- {- "title": "Russia-China Arctic cooperation expands",- "description": "Joint development of Arctic shipping routes and resource extraction projects",- "source": "Arctic Affairs",- "date": "2024-10-05",- "region": "arctic/russia"- },- {- "title": "NATO discusses eastern European troop deployments",- "description": "Alliance considers permanent military presence in Poland and Baltic states",- "source": "Security Briefing",- "date": "2024-09-28",- "region": "europe/nato"- },- {- "title": "Russian energy diplomacy through pipeline control",- "description": "Moscow leverages natural gas infrastructure for political influence in Europe",- "source": "Energy Analysis",- "date": "2024-09-20",- "region": "europe/russia"- }- ]-- # Create mock agent state- mock_state = {- "current_events": test_events,- "analysis_parameters": {- "framework": "marshalls_geographic_determinism",- "region": "russia",- "compliance_threshold": 0.7- }- }-- try:- # Import the Russia geography agent- from region_agents.russia_geography_agent import russia_geography_agent-- # Run the agent- print("📊 Running Russia Geography Agent analysis...")- analysis_result = russia_geography_agent(mock_state)-- # Validate the results- print("\n🔍 Analysis Results:")- print(f"Agent: {analysis_result.get('agent', 'Unknown')}")- print(f"Framework: {analysis_result.get('framework', 'Unknown')}")- print(f"Region: {analysis_result.get('region', 'Unknown')}")-- # Check Marshall compliance- marshall_compliance = analysis_result.get('marshall_compliance_score', 0.0)- print(f"\n📈 Marshall Thesis Compliance Score: {marshall_compliance:.3f}")-- if marshall_compliance >= 0.7:- print("✅ PASS - Meets Marshall's geographic determinism requirements")- else:- print("❌ FAIL - Below 70% Marshall compliance threshold")- print(" - Need stronger geographic determinism focus")- print(" - Improve historical pattern recognition")- print(" - Enhance strategic imperative identification")-- # Analyze constraint levels- event_analyses = analysis_result.get('event_analyses', [])- if event_analyses:- print(f"\n🎯 Event Analysis Summary:")- for i, event_analysis in enumerate(event_analyses[:3], 1):- event_name = event_analysis.get('event', 'Unknown')- constraint_level = event_analysis.get('constraint_level', 0.0)- geographic_determinants = event_analysis.get('geographic_determinants', [])-- print(f" {i}. {event_name}")- print(f" Geographic Determinants: {', '.join(geographic_determinants)}")- print(f" Constraint Level: {constraint_level:.2f}")-- # Check strategic imperatives- strategic_imperatives = analysis_result.get('strategic_imperatives', {})- primary_imperatives = strategic_imperatives.get('primary_imperatives', [])-- print(f"\n🎯 Strategic Imperatives Identified: {len(primary_imperatives)}")- for imperative in primary_imperatives:- imperative_name = imperative.get('imperative', 'Unknown')- geographic_driver = imperative.get('geographic_driver', 'Unknown')- print(f" - {imperative_name}")- print(f" Driver: {geographic_driver}")-- # Validate geographic determinism focus- determinism_focus = analysis_result.get('determinism_focus', 0.0)- print(f"\n🏔️ Geographic Determinism Focus: {determinism_focus:.3f}")-- # Check historical patterns- historical_patterns = analysis_result.get('historical_patterns', {})- print(f"\n📚 Historical Patterns Identified:")- for pattern_type, pattern_data in historical_patterns.items():- if isinstance(pattern_data, dict) and pattern_data.get('geographic_determinism'):- pattern_name = pattern_data.get('pattern', 'Unknown')- print(f" - {pattern_type}: {pattern_name}")-- # Test predictions- predictions = analysis_result.get('geographic_predictions', [])- print(f"\n🔮 Geographic Predictions: {len(predictions)}")- for prediction in predictions[:2]: # Show first 2- pred_behavior = prediction.get('prediction', 'Unknown')- confidence = prediction.get('confidence', 0.0)- geographic_driver = prediction.get('geographic_driver', 'Unknown')- print(f" - {pred_behavior}")- print(f" Driver: {geographic_driver}, Confidence: {confidence:.2f}")-- # Overall test result- print("\n" + "=" * 80)- print("🧪 TEST SUMMARY:")-- test_passed = (- marshall_compliance >= 0.7 and- len(primary_imperatives) >= 2 and- determinism_focus >= 0.5- )-- if test_passed:- print("✅ RUSSIA GEOGRAPHY AGENT TEST PASSED")- print(" - Marshall thesis compliance achieved")- print(" - Strategic imperatives identified")- print(" - Geographic determinism focus maintained")- else:- print("❌ RUSSIA GEOGRAPHY AGENT TEST FAILED")- if marshall_compliance < 0.7:- print(" - Marshall compliance below threshold")- if len(primary_imperatives) < 2:- print(" - Insufficient strategic imperatives")- if determinism_focus < 0.5:- print(" - Weak geographic determinism focus")-- return test_passed-- except ImportError as e:- print(f"❌ Import Error: {e}")- print(" - Check module imports and file structure")- return False- except Exception as e:- print(f"❌ Test Error: {e}")- return False--def validate_marshall_thesis_components(analysis_result):- """- Validate that all Marshall thesis components are present-- Marshall's Geographic Determinism Requirements:- 1. Geographic DETERMINISM (not just influence)- 2. Historical pattern recognition- 3. Strategic imperative identification- 4. Constraint over choice emphasis- """-- components = {- "geographic_determinism": False,- "historical_patterns": False,- "strategic_imperatives": False,- "constraint_emphasis": False- }-- # Check geographic determinism- constraint_analysis = analysis_result.get('constraint_analysis', [])- if constraint_analysis and any(analysis.get('marshall_determinism_score', 0) > 0.5- for analysis in constraint_analysis):- components["geographic_determinism"] = True-- # Check historical patterns- historical_patterns = analysis_result.get('historical_patterns', {})- if historical_patterns and any(pattern.get('geographic_determinism', False)- for pattern in historical_patterns.values()- if isinstance(pattern, dict)):- components["historical_patterns"] = True-- # Check strategic imperatives- strategic_imperatives = analysis_result.get('strategic_imperatives', {})- primary_imperatives = strategic_imperatives.get('primary_imperatives', [])- if len(primary_imperatives) >= 2:- components["strategic_imperatives"] = True-- # Check constraint emphasis- determinism_focus = analysis_result.get('determinism_focus', 0.0)- if determinism_focus >= 0.5:- components["constraint_emphasis"] = True-- return components--def run_detailed_validation():- """- Run detailed validation of Marshall thesis compliance- """-- print("\n🔬 DETAILED MARSHALL THESIS VALIDATION")- print("-" * 50)-- # Run basic test- test_passed = test_russia_geography_agent()-- if test_passed:- print("\n✅ All validation checks passed")- print("🎉 Russia Geography Agent is ready for production")- else:- print("\n⚠️ Some validation checks failed")- print("🔧 Agent needs refinement before production deployment")-- return test_passed--if __name__ == "__main__":- print("🚀 Starting Russia Geography Agent Test Suite")- print("Testing Tim Marshall's Geographic Determinism Framework")- print("Required: 70%+ Marshall thesis compliance")- print()-- success = run_detailed_validation()-- if success:- print("\n🎯 Test completed successfully!")- sys.exit(0)- else:- print("\n❌ Test failed - check output above for details")- sys.exit(1)\ No newline at end of filediff --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.pynew file mode 100644index 000000000..51629d26d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/american_order_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..51629d26d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/chinese_order_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..51629d26d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/european_order_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..51629d26d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/islamic_order_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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.pynew file mode 100644index 000000000..51629d26d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/WorldOrderAgents/multipolar_order_agent.py@@ -0,0 +1,111 @@+"""+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():+ """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()++ 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/World_Order_Agents/README.md b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/README.mddeleted file mode 100644index ab700b1c5..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/README.md+++ /dev/null@@ -1,189 +0,0 @@-# World Order Agents - Henry Kissinger Framework--## 📚 Book Overview-**"World Order: Reflections on the Character of Nations and the Course of History"** by Henry Kissinger--### Core Thesis-Different civilizations have developed distinct conceptions of world order throughout history. The modern global system requires understanding and reconciling these diverse approaches - particularly the European balance of power system, Islamic concepts of international relations, Chinese hierarchical order, and American exceptionalism.--## 🗂️ Folder Structure-```-World_Order_Agents/-├── README.md # This file - overview and guide-├── WORLD_ORDER_AGENT_GUIDE.md # Implementation guide-├── civilization_agents/ # Individual civilization agents-│ ├── westphalian_europe_agent.py # European balance of power system-│ ├── islamic_world_agent.py # Islamic concepts of world order-│ ├── chinese_world_agent.py # Chinese hierarchical order-│ ├── american_world_agent.py # American exceptionalism & liberal order-│ ├── balance_power_agent.py # Realpolitik & balance of power theory-│ ├── nuclear_order_agent.py # Nuclear deterrence & arms control-│ ├── digital_age_agent.py # Cyber sovereignty & modern challenges-│ └── global_governance_agent.py # International institutions & law-├── diplomatic_modules/ # Shared diplomatic analysis tools-│ ├── realpolitik_analysis.py-│ ├── balance_power_calculations.py-│ ├── historical_continuity.py-│ └── order_system_comparison.py-└── test_agents/ # Testing suite- ├── westphalian_order_test.py- ├── islamic_order_test.py- ├── chinese_order_test.py- └── [other_tests]-```--## 🎯 Major World Order Systems (Based on Book Structure)--### 1. **European Westphalian System**-- **Core Concept**: Balance of power through sovereign states-- **Historical Origin**: Peace of Westphalia (1648) - nation-state sovereignty-- **Key Principles**: Sovereign equality, balance of power, concert of Europe-- **Strategic Logic**: Prevent hegemony through coalitions and diplomacy-- **Modern Relevance**: UN, EU, international law, diplomatic protocols--### 2. **Islamic World Order**-- **Core Concept**: Unity of faith (Ummah) and political authority-- **Historical Origin**: Caliphate system and Islamic political theory-- **Key Principles**: Religious legitimacy, community unity, just governance-- **Strategic Logic**: Balance between religious authority and political power-- **Modern Relevance**: Political Islam, state-religion relations, regional dynamics--### 3. **Chinese World Order**-- **Core Concept**: Hierarchical system with Middle Kingdom centrality-- **Historical Origin**: Imperial China and tributary system-- **Key Principles**: Cultural superiority, hierarchical relationships, harmony-- **Strategic Logic**: Central authority with peripheral acknowledgment-- **Modern Relevance**: China's rise, regional influence, Belt and Road Initiative--### 4. **American World Order**-- **Core Concept**: Liberal internationalism with American leadership-- **Historical Origin**: Post-WWII American global leadership-- **Key Principles**: Democratic values, free markets, international institutions-- **Strategic Logic**: American exceptionalism, universal values, power projection-- **Modern Relevance**: Alliances, international economics, democracy promotion--### 5. **Balance of Power System**-- **Core Concept**: Realpolitik and power equilibrium maintenance-- **Historical Origin**: European state system evolution-- **Key Principles**: Power calculations, alliance formation, deterrence-- **Strategic Logic**: Prevent dominance through counterbalancing-- **Modern Relevance**: Great power competition, alliance systems, regional security--### 6. **Nuclear Order**-- **Core Concept**: Deterrence through mutual assured destruction-- **Historical Origin**: Cold War nuclear standoff-- **Key Principles**: MAD, arms control, nuclear non-proliferation-- **Strategic Logic**: Deterrence stability, crisis management-- **Modern Relevance**: Nuclear proliferation, new nuclear powers, arms control--## 🤖 Agent Implementation Guidelines--### Kissinger Framework Requirements-Each agent must demonstrate:--1. **Historical Continuity**: Show how historical patterns persist in modern politics-2. **Civilizational Understanding**: Deep knowledge of specific cultural/historical context-3. **Realpolitik Analysis**: Power-based calculations over ideological preferences-4. **Diplomatic Nuance**: Understanding of subtle diplomatic maneuvering-5. **Order System Logic**: How each civilization conceives of international relations--### Agent Structure Template-```python-"""-CIVILIZATION ORDER AGENT - Henry Kissinger Framework--Core Thesis: Different civilizations have distinct conceptions of world order-- Historical continuity shapes modern international behavior-- Civilizational concepts influence diplomatic approaches-- Balance of power considerations override ideological preferences-- Order systems must be understood on their own terms--Kissinger Compliance Required: Historical continuity, realpolitik analysis, civilizational understanding-"""-```--### Data Sources Required-- Historical patterns and continuity-- Civilizational diplomatic traditions-- Power calculations and balance considerations-- Current geopolitical events through historical lens-- Diplomatic practices and protocols--## 🎯 Success Criteria--### Agent Quality Standards-- ✅ **Historical Continuity**: Show connection between past and present-- ✅ **Civilizational Expertise**: Deep understanding of specific order system-- ✅ **Realpolitik Analysis**: Power-based rather than ideological analysis-- ✅ **Diplomatic Nuance**: Subtle understanding of diplomatic practices-- ✅ **Framework Fidelity**: Strict adherence to Kissinger's approach--### Expected Outputs-- **Historical Pattern Analysis**: How past shapes present behavior-- **Civilizational Logic**: How different cultures conceive international relations-- **Power Balance Calculations**: Realpolitik assessment of situations-- **Diplomatic Recommendations**: Kissinger-style diplomatic approaches-- **Order System Comparison**: How different systems interact and conflict--## 🧪 Testing & Usage--### Quick Start-```bash-# Test individual civilization agents-python test_agents/westphalian_order_test.py-python test_agents/islamic_order_test.py-python test_agents/chinese_order_test.py--# Balance of power analysis-python diplomatic_modules/balance_power_calculations.py --situation ukraine--# Order system comparison-python diplomatic_modules/order_system_comparison.py --systems westphalian,chinese-```--### Frontend Integration-```bash-# World order analysis commands-/worldorder analyze westphalian ukraine-sovereignty-/worldorder analyze chinese south-china-sea-hierarchy-/worldorder compare westphalian islamic middle-east-governance-/worldorder balance russia-china power-dynamics-```--## 🔍 Key Kissinger Concepts--### Historical Continuity-- "History is not a narrative of progress but a cyclical pattern"-- Past diplomatic practices inform present behavior-- Civilizational memory shapes modern responses--### Realpolitik Approach-- Power considerations override ideological preferences-- National interest defined in power terms-- Moral considerations secondary to strategic calculations--### Balance of Power Logic-- Prevent emergence of regional hegemons-- Form coalitions to counterbalance dominant powers-- Maintain equilibrium through diplomatic maneuvering--### Diplomatic Practice-- Subtle communication and signaling-- Back-channel negotiations-- Face-saving arrangements-- Gradual rather than transformative changes--## 🚀 Getting Started--1. **Study Kissinger's Framework** - Understand historical continuity and realpolitik-2. **Choose Your Civilization** - Select specific order system to analyze-3. **Implement Agent** - Use template and follow diplomatic history approach-4. **Test Historical Patterns** - Validate continuity from past to present-5. **Validate Framework** - Ensure deep civilizational understanding-6. **Deploy** - Integrate with Fincept Terminal commands--## 📞 Implementation Support--This framework converts Henry Kissinger's diplomatic history approach into AI agents that analyze current events through the lens of different civilizational concepts of world order, emphasizing historical continuity and realpolitik calculations.--For each agent, focus on showing how historical patterns and civilizational concepts shape modern international behavior, following Kissinger's emphasis on understanding each order system on its own terms.\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/american_world_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/american_world_agent.pydeleted file mode 100644index c8534d1dd..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/american_world_agent.py+++ /dev/null@@ -1,264 +0,0 @@-"""-AMERICAN WORLD ORDER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - american_diplomatic_history-# - exceptionalism_concepts-# - liberal_internationalism_data-#-# OUTPUT:-# - American liberal order analysis-# - Exceptionalism influence assessment-# - Alliance system evaluation-# - Historical continuity from Wilsonian traditions-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_american_order"-# - historical_context="wilsonian_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def american_world_agent(state: AgentState) -> Dict[str, Any]:- """- AMERICAN WORLD ORDER AGENT - Henry Kissinger Framework-- Core Thesis: American civilization has distinct liberal internationalist conceptions of world order- - American exceptionalism and universal values promotion- - Liberal democratic order with American leadership- - Alliance systems based on shared values and security- - Historical continuity from Wilsonian internationalism-- Kissinger Compliance Required: Understanding American diplomatic tradition, balance between idealism and realism- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'american_order_analysis': {- 'exceptionalism_influence': None,- 'liberal_values_promotion': None,- 'alliance_system_impact': None- },- 'global_leadership': {- 'american_power_projection': [],- 'international_institutions_support': [],- 'democracy_promotion_efforts': []- },- 'historical_continuity': {- 'wilsonian_legacy': [],- 'cold_war_traditions': [],- 'liberal_internationalism_patterns': []- },- 'diplomatic_recommendations': {- 'american_framework_solutions': [],- 'alliance_coordination': [],- 'international_leadership_opportunities': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'american_understanding_score': 0,- 'realpolitik_balance_score': 0- }- }-- # Process each current event through American order framework- for event in current_events:- event_analysis = analyze_event_american_order(event)-- # Update analysis results- analysis_results['american_order_analysis']['exceptionalism_influence'] = \- event_analysis.get('exceptionalism_impact')- analysis_results['global_leadership']['american_power_projection'].extend(- event_analysis.get('power_projection', [])- )- analysis_results['historical_continuity']['wilsonian_legacy'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_american_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_american_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'American World agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'american_world'- }--def analyze_event_american_order(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through American order framework-- Key American Order Concepts (Kissinger Interpretation):- 1. American Exceptionalism - Unique role in promoting democracy and freedom- 2. Liberal Internationalism - International order based on democratic values- 3. Alliance Systems - Security commitments and shared values- 4. Institutional Leadership - UN, NATO, Bretton Woods system leadership- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'exceptionalism_impact': None,- 'power_projection': [],- 'historical_patterns': [],- 'american_order_compliance': 0- }-- # Analyze American exceptionalism influence- if 'usa' in str(actors).lower() or 'america' in description.lower():- analysis['exceptionalism_impact'] = 'American exceptionalism in international action'- analysis['american_order_compliance'] += 25-- # Check for alliance system involvement- if any(alliance in str(actors).lower() for alliance in ['nato', 'un', 'alliance']):- analysis['power_projection'].append('American alliance system leadership')- analysis['american_order_compliance'] += 25-- # Identify historical patterns- if any(value in description.lower() for value in ['democracy', 'freedom', 'human rights']):- analysis['historical_patterns'].append('Wilsonian liberal internationalism')- analysis['american_order_compliance'] += 25-- # Check for institutional leadership- if any(institution in str(actors).lower() for institution in ['un', 'world bank', 'imf']):- analysis['historical_patterns'].append('American international institutional leadership')- analysis['american_order_compliance'] += 25-- return analysis--def calculate_american_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's American world order framework-- Kissinger American Framework Requirements:- 1. American Understanding (35%): Deep knowledge of American diplomatic tradition- 2. Historical Continuity (30%): Connection to Wilsonian and Cold War traditions- 3. Realpolitik Balance (25%): Balance between idealism and power considerations- 4. Global Leadership (10%): American role in international order- """-- score = 0.0-- # American Understanding (35%)- exceptionalism_assessment = analysis.get('american_order_analysis', {}).get('exceptionalism_influence')- if exceptionalism_assessment:- score += 35-- # Historical Continuity (30%)- wilsonian_legacy = analysis.get('historical_continuity', {}).get('wilsonian_legacy', [])- if len(wilsonian_legacy) > 0:- score += 30 * min(len(wilsonian_legacy) / 2, 1.0)-- # Realpolitik Balance (25%)- alliance_impact = analysis.get('american_order_analysis', {}).get('alliance_system_impact')- if alliance_impact:- score += 25-- # Global Leadership (10%)- power_projection = analysis.get('global_leadership', {}).get('american_power_projection', [])- if len(power_projection) > 0:- score += 10-- return min(score, 100.0)--def generate_american_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on American order principles- """-- recommendations = {- 'american_framework_solutions': [],- 'alliance_coordination': [],- 'international_leadership_opportunities': []- }-- # American Framework Solutions- exceptionalism_impact = analysis.get('american_order_analysis', {}).get('exceptionalism_influence')- if exceptionalism_impact:- recommendations['american_framework_solutions'].extend([- 'Balance American exceptionalism with realpolitik considerations',- 'Use American values as diplomatic tools while recognizing power realities',- 'Apply liberal internationalism within practical constraints'- ])-- # Alliance Coordination- alliance_impact = analysis.get('american_order_analysis', {}).get('alliance_system_impact')- if alliance_impact:- recommendations['alliance_coordination'].extend([- 'Strengthen traditional alliance systems while adapting to new challenges',- 'Use American alliance leadership for regional stability',- 'Balance alliance commitments with power considerations'- ])-- # International Leadership- power_projection = analysis.get('global_leadership', {}).get('american_power_projection', [])- if len(power_projection) > 0:- recommendations['international_leadership_opportunities'].extend([- 'Exercise American institutional leadership responsibly',- 'Use American power to maintain international order',- 'Balance leadership with burden-sharing considerations'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of American world geopolitical events- test_events = [- {- 'type': 'alliance_coordination',- 'actors': ['USA', 'NATO', 'European partners'],- 'location': 'Europe',- 'description': 'American leadership in NATO alliance coordination and security guarantees'- },- {- 'type': 'international_institution_leadership',- 'actors': ['USA', 'UN', 'World Bank'],- 'location': 'Global',- 'description': 'American involvement in international institutions promoting democratic values'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = american_world_agent(test_state)-- print("=== AMERICAN WORLD ORDER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Exceptionalism Influence: {result['american_order_analysis']['exceptionalism_influence']}")- print(f"American Power Projection: {len(result['global_leadership']['american_power_projection'])}")- print(f"Wilsonian Legacy: {result['historical_continuity']['wilsonian_legacy']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/balance_power_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/balance_power_agent.pydeleted file mode 100644index 199d78a3d..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/balance_power_agent.py+++ /dev/null@@ -1,266 +0,0 @@-"""-BALANCE OF POWER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - great_power_relations_data-# - historical_balance_patterns-# - alliance_formation_history-#-# OUTPUT:-# - Balance of power analysis-# - Hegemony threat assessment-# - Coalition opportunities identification-# - Historical pattern recognition from European balance system-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_realpolitik"-# - historical_context="westphalian_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def balance_power_agent(state: AgentState) -> Dict[str, Any]:- """- BALANCE OF POWER AGENT - Henry Kissinger Framework-- Core Thesis: International order maintained through careful balance of power calculations- - Prevent emergence of regional or global hegemons- - Form counterbalancing coalitions against dominant powers- - Use diplomatic flexibility and alliance management- - Historical continuity from European state system evolution-- Kissinger Compliance Required: Realpolitik analysis, power calculations, historical diplomatic practices- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'balance_power_analysis': {- 'hegemony_threats': [],- 'power_equilibrium_status': None,- 'coalition_opportunities': []- },- 'power_dynamics': {- 'great_power_relations': [],- 'alliance_formations': [],- 'strategic_counterbalancing': []- },- 'historical_continuity': {- 'concert_of_europe_patterns': [],- 'metternich_system_legacy': [],- 'bismarckian_diplomacy_examples': []- },- 'diplomatic_recommendations': {- 'realpolitik_solutions': [],- 'coalition_strategies': [],- 'equilibrium_maintenance_actions': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'realpolitik_application_score': 0,- 'historical_continuity_score': 0- }- }-- # Process each current event through balance of power framework- for event in current_events:- event_analysis = analyze_event_balance_power(event)-- # Update analysis results- analysis_results['balance_power_analysis']['hegemony_threats'].extend(- event_analysis.get('hegemony_threats', [])- )- analysis_results['power_dynamics']['great_power_relations'].extend(- event_analysis.get('power_relations', [])- )- analysis_results['historical_continuity']['concert_of_europe_patterns'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_balance_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_balance_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'Balance of Power agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'balance_power'- }--def analyze_event_balance_power(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through balance of power framework-- Key Balance of Power Concepts (Kissinger Interpretation):- 1. Hegemony Prevention - Stop any single power from dominating- 2. Coalition Formation - Build alliances against threatening powers- 3. Power Equilibrium - Maintain stable distribution of power- 4. Diplomatic Flexibility - Shift alliances based on power calculations- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'hegemony_threats': [],- 'power_relations': [],- 'historical_patterns': [],- 'balance_power_compliance': 0- }-- # Analyze hegemony threats- if 'dominance' in description.lower() or 'hegemony' in description.lower():- analysis['hegemony_threats'].append('Potential hegemonic power emergence')- analysis['balance_power_compliance'] += 25-- # Check for great power relations- if len(actors) >= 2 and any(great_power in str(actors).lower()- for great_power in ['usa', 'china', 'russia', 'eu', 'india']):- analysis['power_relations'].append('Great power strategic interaction')- analysis['balance_power_compliance'] += 25-- # Identify historical patterns- if 'alliance' in description.lower() or 'coalition' in description.lower():- analysis['historical_patterns'].append('Traditional balance of power alliance formation')- analysis['balance_power_compliance'] += 25-- # Check for equilibrium considerations- if 'stability' in description.lower() or 'equilibrium' in description.lower():- analysis['historical_patterns'].append('Concert of Europe equilibrium management')- analysis['balance_power_compliance'] += 25-- return analysis--def calculate_balance_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's balance of power framework-- Kissinger Balance Framework Requirements:- 1. Realpolitik Application (40%): Pure power-based calculations- 2. Historical Continuity (30%): Connection to European balance tradition- 3. Power Analysis (20%): Understanding power distribution- 4. Diplomatic Nuance (10%): Subtle alliance management- """-- score = 0.0-- # Realpolitik Application (40%)- hegemony_threats = analysis.get('balance_power_analysis', {}).get('hegemony_threats', [])- if len(hegemony_threats) > 0:- score += 40 * min(len(hegemony_threats) / 2, 1.0)-- # Historical Continuity (30%)- concert_patterns = analysis.get('historical_continuity', {}).get('concert_of_europe_patterns', [])- if len(concert_patterns) > 0:- score += 30 * min(len(concert_patterns) / 2, 1.0)-- # Power Analysis (20%)- power_relations = analysis.get('power_dynamics', {}).get('great_power_relations', [])- if len(power_relations) > 0:- score += 20-- # Diplomatic Nuance (10%)- equilibrium_status = analysis.get('balance_power_analysis', {}).get('power_equilibrium_status')- if equilibrium_status:- score += 10-- return min(score, 100.0)--def generate_balance_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on balance of power principles- """-- recommendations = {- 'realpolitik_solutions': [],- 'coalition_strategies': [],- 'equilibrium_maintenance_actions': []- }-- # Realpolitik Solutions- hegemony_threats = analysis.get('balance_power_analysis', {}).get('hegemony_threats', [])- if len(hegemony_threats) > 0:- recommendations['realpolitik_solutions'].extend([- 'Prioritize power calculations over ideological preferences',- 'Focus on preventing hegemonic dominance through strategic actions',- 'Apply historical balance of power logic to current challenges'- ])-- # Coalition Strategies- coalition_opportunities = analysis.get('balance_power_analysis', {}).get('coalition_opportunities', [])- if len(coalition_opportunities) > 0:- recommendations['coalition_strategies'].extend([- 'Form flexible coalitions to counterbalance emerging powers',- 'Use diplomatic engagement to build anti-hegemonic partnerships',- 'Maintain alliance flexibility based on shifting power dynamics'- ])-- # Equilibrium Maintenance- power_relations = analysis.get('power_dynamics', {}).get('great_power_relations', [])- if len(power_relations) > 0:- recommendations['equilibrium_maintenance_actions'].extend([- 'Manage great power relations through careful balance maintenance',- 'Use diplomatic tools to prevent power concentration',- 'Apply lessons from historical European balance of power systems'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of balance of power geopolitical events- test_events = [- {- 'type': 'great_power_competition',- 'actors': ['USA', 'China', 'Russia'],- 'location': 'Global',- 'description': 'Great power competition threatening global equilibrium and risking hegemonic dominance'- },- {- 'type': 'alliance_formation',- 'actors': ['European powers', 'NATO', 'partners'],- 'location': 'Europe',- 'description': 'Coalition building to maintain regional balance and counterbalance threats'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = balance_power_agent(test_state)-- print("=== BALANCE OF POWER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Hegemony Threats: {len(result['balance_power_analysis']['hegemony_threats'])}")- print(f"Great Power Relations: {len(result['power_dynamics']['great_power_relations'])}")- print(f"Concert of Europe Patterns: {result['historical_continuity']['concert_of_europe_patterns']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/chinese_world_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/chinese_world_agent.pydeleted file mode 100644index aafd9de68..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/chinese_world_agent.py+++ /dev/null@@ -1,264 +0,0 @@-"""-CHINESE WORLD ORDER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - chinese_imperial_history-# - tributary_system_data-# - middle_kingdom_concepts-#-# OUTPUT:-# - Chinese hierarchical order analysis-# - Tributary system influence assessment-# - Middle Kingdom centrality evaluation-# - Historical continuity from imperial traditions-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_chinese_order"-# - historical_context="imperial_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def chinese_world_agent(state: AgentState) -> Dict[str, Any]:- """- CHINESE WORLD ORDER AGENT - Henry Kissinger Framework-- Core Thesis: Chinese civilization has distinct hierarchical conceptions of world order- - Middle Kingdom centrality with hierarchical relationships- - Tributary system based on cultural superiority and benevolence- - Mandate of Heaven concept legitimizing authority- - Historical continuity from imperial to modern Chinese worldview-- Kissinger Compliance Required: Understanding Chinese political culture, historical continuity, hierarchical thinking- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'chinese_order_analysis': {- 'middle_kingdom_centrality': None,- 'hierarchical_relationships': None,- 'tributary_system_influence': None- },- 'regional_dynamics': {- 'chinese_sphere_influence': [],- 'tributary_modern_equivalents': [],- 'regional_harmony_assessment': None- },- 'historical_continuity': {- 'imperial_legacy': [],- 'mandate_of_heaven_modern_forms': [],- 'tributary_patterns': []- },- 'diplomatic_recommendations': {- 'chinese_framework_solutions': [],- 'hierarchical_engagement': [],- 'regional_coordination_opportunities': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'chinese_cultural_understanding': 0,- 'historical_continuity_score': 0- }- }-- # Process each current event through Chinese order framework- for event in current_events:- event_analysis = analyze_event_chinese_order(event)-- # Update analysis results- analysis_results['chinese_order_analysis']['middle_kingdom_centrality'] = \- event_analysis.get('centrality_impact')- analysis_results['regional_dynamics']['chinese_sphere_influence'].extend(- event_analysis.get('sphere_influence', [])- )- analysis_results['historical_continuity']['imperial_legacy'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_chinese_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_chinese_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'Chinese World agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'chinese_world'- }--def analyze_event_chinese_order(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through Chinese order framework-- Key Chinese Order Concepts (Kissinger Interpretation):- 1. Middle Kingdom - China as cultural and political center- 2. Hierarchical relationships - Different from Westphalian equality- 3. Tributary system - Regional order based on Chinese benevolence- 4. Mandate of Heaven - Legitimacy through harmony and prosperity- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'centrality_impact': None,- 'sphere_influence': [],- 'historical_patterns': [],- 'chinese_order_compliance': 0- }-- # Analyze Middle Kingdom centrality- if 'china' in str(actors).lower() or 'chinese' in description.lower():- analysis['centrality_impact'] = 'Chinese centrality in regional order'- analysis['chinese_order_compliance'] += 25-- # Check for hierarchical relationship patterns- if any('asean' in actor.lower() or 'asia' in actor.lower() for actor in actors):- analysis['sphere_influence'].append('Chinese regional hierarchy')- analysis['chinese_order_compliance'] += 25-- # Identify historical patterns- if 'influence' in description.lower() and 'region' in description.lower():- analysis['historical_patterns'].append('Tributary system modern equivalents')- analysis['chinese_order_compliance'] += 25-- # Check for harmony and legitimacy concepts- if any(word in description.lower() for word in ['harmony', 'stability', 'cooperation']):- analysis['historical_patterns'].append('Mandate of Heaven legitimacy concepts')- analysis['chinese_order_compliance'] += 25-- return analysis--def calculate_chinese_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's Chinese world order framework-- Kissinger Chinese Framework Requirements:- 1. Cultural Understanding (35%): Deep knowledge of Chinese political culture- 2. Historical Continuity (30%): Connection to imperial traditions- 3. Hierarchical Analysis (25%): Understanding non-Western state relations- 4. Regional Dynamics (10%): Chinese sphere of influence considerations- """-- score = 0.0-- # Cultural Understanding (35%)- centrality_assessment = analysis.get('chinese_order_analysis', {}).get('middle_kingdom_centrality')- if centrality_assessment:- score += 35-- # Historical Continuity (30%)- imperial_legacy = analysis.get('historical_continuity', {}).get('imperial_legacy', [])- if len(imperial_legacy) > 0:- score += 30 * min(len(imperial_legacy) / 2, 1.0)-- # Hierarchical Analysis (25%)- hierarchical_relations = analysis.get('chinese_order_analysis', {}).get('hierarchical_relationships')- if hierarchical_relations:- score += 25-- # Regional Dynamics (10%)- sphere_influence = analysis.get('regional_dynamics', {}).get('chinese_sphere_influence', [])- if len(sphere_influence) > 0:- score += 10-- return min(score, 100.0)--def generate_chinese_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on Chinese order principles- """-- recommendations = {- 'chinese_framework_solutions': [],- 'hierarchical_engagement': [],- 'regional_coordination_opportunities': []- }-- # Chinese Framework Solutions- centrality_impact = analysis.get('chinese_order_analysis', {}).get('middle_kingdom_centrality')- if centrality_impact:- recommendations['chinese_framework_solutions'].extend([- 'Recognize Chinese historical sense of centrality',- 'Engage with Chinese concepts of regional order',- 'Respect Chinese cultural perspectives on international relations'- ])-- # Hierarchical Engagement- hierarchical_relations = analysis.get('chinese_order_analysis', {}).get('hierarchical_relationships')- if hierarchical_relations:- recommendations['hierarchical_engagement'].extend([- 'Work within Chinese hierarchical relationship frameworks',- 'Understand Chinese preference for order over equality',- 'Respect Chinese concepts of benevolent regional leadership'- ])-- # Regional Coordination- sphere_influence = analysis.get('regional_dynamics', {}).get('chinese_sphere_influence', [])- if len(sphere_influence) > 0:- recommendations['regional_coordination_opportunities'].extend([- 'Support regional organizations that align with Chinese worldviews',- 'Facilitate Chinese participation in regional governance',- 'Work with Chinese historical patterns of regional interaction'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of Chinese world geopolitical events- test_events = [- {- 'type': 'regional_initiative',- 'actors': ['China', 'ASEAN', 'Belt and Road'],- 'location': 'Asia-Pacific',- 'description': 'Chinese-led regional cooperation and infrastructure development'- },- {- 'type': 'cultural_influence',- 'actors': ['China', 'regional_partners'],- 'location': 'East Asia',- 'description': 'Chinese cultural and economic influence expanding in region'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = chinese_world_agent(test_state)-- print("=== CHINESE WORLD ORDER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Middle Kingdom Centrality: {result['chinese_order_analysis']['middle_kingdom_centrality']}")- print(f"Chinese Sphere Influence: {len(result['regional_dynamics']['chinese_sphere_influence'])}")- print(f"Imperial Legacy: {result['historical_continuity']['imperial_legacy']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/islamic_world_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/islamic_world_agent.pydeleted file mode 100644index a431fad97..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/islamic_world_agent.py+++ /dev/null@@ -1,265 +0,0 @@-"""-ISLAMIC WORLD ORDER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - islamic_history_data-# - caliphate_traditions-# - religious_authority_structures-#-# OUTPUT:-# - Islamic order concept analysis-# - Ummah unity assessment-# - Religious-political authority balance-# - Historical continuity from Islamic traditions-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_islamic_order"-# - historical_context="caliphate_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def islamic_world_agent(state: AgentState) -> Dict[str, Any]:- """- ISLAMIC WORLD ORDER AGENT - Henry Kissinger Framework-- Core Thesis: Islamic civilization has distinct conceptions of world order- - Unity of faith (Ummah) transcends state boundaries- - Caliphate tradition combines religious and political authority- - Distinction between Dar al-Islam (House of Islam) and Dar al-Harb (House of War)- - Historical continuity affects modern Islamic political movements-- Kissinger Compliance Required: Understanding Islamic political theory, historical continuity, religious-political dynamics- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'islamic_order_analysis': {- 'ummah_unity_assessment': None,- 'religious_authority_impact': None,- 'caliphate_tradition_influence': None- },- 'regional_dynamics': {- 'islamic_state_relations': [],- 'religious_political_balance': None,- 'sectarian_considerations': []- },- 'historical_continuity': {- 'caliphate_legacy': [],- 'islamic_legal_traditions': [],- 'historical_precedents': []- },- 'diplomatic_recommendations': {- 'islamic_framework_solutions': [],- 'religious_authority_engagement': [],- 'regional_coordination_opportunities': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'islamic_understanding_score': 0,- 'historical_continuity_score': 0- }- }-- # Process each current event through Islamic order framework- for event in current_events:- event_analysis = analyze_event_islamic_order(event)-- # Update analysis results- analysis_results['islamic_order_analysis']['ummah_unity_assessment'] = \- event_analysis.get('ummah_impact')- analysis_results['regional_dynamics']['islamic_state_relations'].extend(- event_analysis.get('islamic_relations', [])- )- analysis_results['historical_continuity']['caliphate_legacy'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_islamic_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_islamic_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'Islamic World agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'islamic_world'- }--def analyze_event_islamic_order(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through Islamic order framework-- Key Islamic Order Concepts (Kissinger Interpretation):- 1. Ummah - Global community of believers transcending state boundaries- 2. Caliphate tradition - Religious and political authority combined- 3. Dar al-Islam vs Dar al-Harb - Islamic vs non-Islamic world distinction- 4. Sharia law - Islamic legal framework governing society- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'ummah_impact': None,- 'islamic_relations': [],- 'historical_patterns': [],- 'islamic_order_compliance': 0- }-- # Analyze Ummah implications- if any('muslim' in actor.lower() for actor in actors) or 'islamic' in description.lower():- analysis['ummah_impact'] = 'Affects Muslim community beyond state boundaries'- analysis['islamic_order_compliance'] += 25-- # Check for religious-political authority dynamics- if any('government' in actor.lower() or 'religious' in actor.lower() for actor in actors):- analysis['islamic_relations'].append('Religious-political authority interaction')- analysis['islamic_order_compliance'] += 25-- # Identify historical patterns- if 'conflict' in description.lower() and any(middle_east_country in location.lower()- for middle_east_country in ['iraq', 'iran', 'saudi', 'syria', 'egypt']):- analysis['historical_patterns'].append('Historical Islamic regional dynamics')- analysis['islamic_order_compliance'] += 25-- # Check for caliphate tradition influence- if 'unity' in description.lower() or 'pan-islamic' in description.lower():- analysis['historical_patterns'].append('Caliphate tradition of unity')- analysis['islamic_order_compliance'] += 25-- return analysis--def calculate_islamic_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's Islamic world order framework-- Kissinger Islamic Framework Requirements:- 1. Islamic Understanding (35%): Deep knowledge of Islamic political theory- 2. Historical Continuity (30%): Connection to caliphate and Islamic traditions- 3. Religious-Political Analysis (25%): Balance of faith and state power- 4. Regional Dynamics (10%): Islamic world regional considerations- """-- score = 0.0-- # Islamic Understanding (35%)- ummah_assessment = analysis.get('islamic_order_analysis', {}).get('ummah_unity_assessment')- if ummah_assessment:- score += 35-- # Historical Continuity (30%)- caliphate_legacy = analysis.get('historical_continuity', {}).get('caliphate_legacy', [])- if len(caliphate_legacy) > 0:- score += 30 * min(len(caliphate_legacy) / 2, 1.0)-- # Religious-Political Analysis (25%)- religious_balance = analysis.get('regional_dynamics', {}).get('religious_political_balance')- if religious_balance:- score += 25-- # Regional Dynamics (10%)- islamic_relations = analysis.get('regional_dynamics', {}).get('islamic_state_relations', [])- if len(islamic_relations) > 0:- score += 10-- return min(score, 100.0)--def generate_islamic_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on Islamic order principles- """-- recommendations = {- 'islamic_framework_solutions': [],- 'religious_authority_engagement': [],- 'regional_coordination_opportunities': []- }-- # Islamic Framework Solutions- ummah_impact = analysis.get('islamic_order_analysis', {}).get('ummah_unity_assessment')- if ummah_impact:- recommendations['islamic_framework_solutions'].extend([- 'Recognize transnational Islamic community interests',- 'Engage with Islamic concepts of justice and authority',- 'Consider Islamic legal traditions in diplomatic approaches'- ])-- # Religious Authority Engagement- caliphate_influence = analysis.get('islamic_order_analysis', {}).get('caliphate_tradition_influence')- if caliphate_influence:- recommendations['religious_authority_engagement'].extend([- 'Engage legitimate religious authorities in conflict resolution',- 'Respect religious-political authority structures',- 'Work through Islamic legal frameworks where appropriate'- ])-- # Regional Coordination- islamic_relations = analysis.get('regional_dynamics', {}).get('islamic_state_relations', [])- if len(islamic_relations) > 0:- recommendations['regional_coordination_opportunities'].extend([- 'Facilitate Islamic regional cooperation mechanisms',- 'Support organizations that work within Islamic frameworks',- 'Consider Islamic historical precedents for conflict resolution'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of Islamic world geopolitical events- test_events = [- {- 'type': 'regional_cooperation',- 'actors': ['Saudi Arabia', 'Iran', 'OIC'],- 'location': 'Middle East',- 'description': 'Islamic countries discussing regional cooperation and unity'- },- {- 'type': 'religious_political_dynamics',- 'actors': ['Muslim Brotherhood', 'Egyptian Government'],- 'location': 'Egypt',- 'description': 'Tensions between religious authority and state power'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = islamic_world_agent(test_state)-- print("=== ISLAMIC WORLD ORDER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Ummah Unity Assessment: {result['islamic_order_analysis']['ummah_unity_assessment']}")- print(f"Islamic State Relations: {len(result['regional_dynamics']['islamic_state_relations'])}")- print(f"Caliphate Legacy: {result['historical_continuity']['caliphate_legacy']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/nuclear_order_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/nuclear_order_agent.pydeleted file mode 100644index d8b5584d5..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/nuclear_order_agent.py+++ /dev/null@@ -1,265 +0,0 @@-"""-NUCLEAR ORDER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - nuclear_proliferation_data-# - arms_control_history-# - deterrence_theory_patterns-#-# OUTPUT:-# - Nuclear deterrence analysis-# - Arms control opportunities assessment-# - Proliferation threat evaluation-# - Historical continuity from Cold War nuclear order-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_nuclear_order"-# - historical_context="cold_war_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def nuclear_order_agent(state: AgentState) -> Dict[str, Any]:- """- NUCLEAR ORDER AGENT - Henry Kissinger Framework-- Core Thesis: Nuclear weapons created new form of international order based on deterrence- - Mutual Assured Destruction (MAD) prevents great power war- - Arms control regimes manage nuclear competition- - Nuclear proliferation threats traditional balance of power- - Historical continuity from Cold War crisis management-- Kissinger Compliance Required: Understanding deterrence theory, arms control experience, crisis management- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'nuclear_order_analysis': {- 'deterrence_stability': None,- 'proliferation_threats': [],- 'arms_control_opportunities': []- },- 'strategic_stability': {- 'great_power_nuclear_relations': [],- 'crisis_stability_assessment': None,- 'escalation_control_measures': []- },- 'historical_continuity': {- 'cold_war_legacy': [],- 'arms_control_history_patterns': [],- 'crisis_management_examples': []- },- 'diplomatic_recommendations': {- 'deterrence_maintenance': [],- 'arms_control_initiatives': [],- 'nonproliferation_strategies': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'deterrence_understanding_score': 0,- 'arms_control_experience_score': 0- }- }-- # Process each current event through nuclear order framework- for event in current_events:- event_analysis = analyze_event_nuclear_order(event)-- # Update analysis results- analysis_results['nuclear_order_analysis']['deterrence_stability'] = \- event_analysis.get('deterrence_impact')- analysis_results['nuclear_order_analysis']['proliferation_threats'].extend(- event_analysis.get('proliferation_risks', [])- )- analysis_results['historical_continuity']['cold_war_legacy'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_nuclear_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_nuclear_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'Nuclear Order agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'nuclear_order'- }--def analyze_event_nuclear_order(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through nuclear order framework-- Key Nuclear Order Concepts (Kissinger Interpretation):- 1. Mutual Assured Destruction - Deterrence through mutual vulnerability- 2. Arms Control - Managing nuclear competition through agreements- 3. Nonproliferation - Preventing spread of nuclear weapons- 4. Crisis Stability - Managing crises to avoid nuclear escalation- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'deterrence_impact': None,- 'proliferation_risks': [],- 'historical_patterns': [],- 'nuclear_order_compliance': 0- }-- # Analyze deterrence stability- if any(nuclear_power in str(actors).lower()- for nuclear_power in ['usa', 'russia', 'china', 'nuclear']):- analysis['deterrence_impact'] = 'Nuclear deterrence calculations in great power relations'- analysis['nuclear_order_compliance'] += 25-- # Check for proliferation threats- if 'proliferation' in description.lower() or 'nuclear weapons' in description.lower():- analysis['proliferation_risks'].append('Nuclear weapons proliferation threat')- analysis['nuclear_order_compliance'] += 25-- # Identify historical patterns- if 'arms control' in description.lower() or 'treaty' in description.lower():- analysis['historical_patterns'].append('Cold War arms control tradition')- analysis['nuclear_order_compliance'] += 25-- # Check for crisis stability considerations- if 'crisis' in description.lower() or 'escalation' in description.lower():- analysis['historical_patterns'].append('Nuclear crisis management experience')- analysis['nuclear_order_compliance'] += 25-- return analysis--def calculate_nuclear_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's nuclear order framework-- Kissinger Nuclear Framework Requirements:- 1. Deterrence Understanding (40%): Deep knowledge of nuclear deterrence theory- 2. Arms Control Experience (30%): Connection to Cold War arms control legacy- 3. Proliferation Analysis (20%): Understanding nuclear spread dynamics- 4. Crisis Management (10%): Nuclear escalation control experience- """-- score = 0.0-- # Deterrence Understanding (40%)- deterrence_assessment = analysis.get('nuclear_order_analysis', {}).get('deterrence_stability')- if deterrence_assessment:- score += 40-- # Arms Control Experience (30%)- cold_war_legacy = analysis.get('historical_continuity', {}).get('cold_war_legacy', [])- if len(cold_war_legacy) > 0:- score += 30 * min(len(cold_war_legacy) / 2, 1.0)-- # Proliferation Analysis (20%)- proliferation_threats = analysis.get('nuclear_order_analysis', {}).get('proliferation_threats', [])- if len(proliferation_threats) > 0:- score += 20-- # Crisis Management (10%)- escalation_measures = analysis.get('strategic_stability', {}).get('escalation_control_measures', [])- if len(escalation_measures) > 0:- score += 10-- return min(score, 100.0)--def generate_nuclear_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on nuclear order principles- """-- recommendations = {- 'deterrence_maintenance': [],- 'arms_control_initiatives': [],- 'nonproliferation_strategies': []- }-- # Deterrence Maintenance- deterrence_impact = analysis.get('nuclear_order_analysis', {}).get('deterrence_stability')- if deterrence_impact:- recommendations['deterrence_maintenance'].extend([- 'Maintain stable nuclear deterrence relationships',- 'Preserve mutual vulnerability to prevent first use',- 'Use diplomatic channels to manage nuclear tensions'- ])-- # Arms Control Initiatives- arms_control_opportunities = analysis.get('nuclear_order_analysis', {}).get('arms_control_opportunities', [])- if len(arms_control_opportunities) > 0:- recommendations['arms_control_initiatives'].extend([- 'Pursue new arms control agreements based on Cold War experience',- 'Use historical arms control frameworks for modern challenges',- 'Apply Kissinger-era arms control diplomacy to current proliferation'- ])-- # Nonproliferation Strategies- proliferation_threats = analysis.get('nuclear_order_analysis', {}).get('proliferation_threats', [])- if len(proliferation_threats) > 0:- recommendations['nonproliferation_strategies'].extend([- 'Strengthen nonproliferation regime through diplomatic engagement',- 'Use security guarantees to prevent proliferation incentives',- 'Apply lessons from Cold War proliferation successes and failures'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of nuclear order geopolitical events- test_events = [- {- 'type': 'nuclear_deterrence',- 'actors': ['USA', 'Russia', 'China'],- 'location': 'Global',- 'description': 'Great power nuclear deterrence stability and strategic arms control discussions'- },- {- 'type': 'proliferation_concern',- 'actors': ['International community', 'proliferating_state'],- 'location': 'Region X',- 'description': 'Nuclear proliferation threat and international nonproliferation response'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = nuclear_order_agent(test_state)-- print("=== NUCLEAR ORDER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Deterrence Stability: {result['nuclear_order_analysis']['deterrence_stability']}")- print(f"Proliferation Threats: {len(result['nuclear_order_analysis']['proliferation_threats'])}")- print(f"Cold War Legacy: {result['historical_continuity']['cold_war_legacy']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/westphalian_europe_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/westphalian_europe_agent.pydeleted file mode 100644index 0647963a4..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/civilization_agents/westphalian_europe_agent.py+++ /dev/null@@ -1,263 +0,0 @@-"""-WESTPHALIAN EUROPE ORDER AGENT - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - current_events (array)-# - GEOPOLITICAL_API_KEY-# - historical_treaties_data-# - diplomatic_protocols-#-# OUTPUT:-# - Westphalian sovereignty analysis-# - Balance of power calculations-# - European diplomatic tradition assessment-# - Historical continuity patterns-#-# PARAMETERS:-# - analysis_depth="comprehensive"-# - framework="kissinger_realpolitik"-# - historical_context="westphalian_to_modern"-"""--from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning-from fincept_terminal.Agents.src.tools.api import get_geopolitical_data-from typing import Dict, List, Any-import json--def westphalian_europe_agent(state: AgentState) -> Dict[str, Any]:- """- WESTPHALIAN EUROPE ORDER AGENT - Henry Kissinger Framework-- Core Thesis: European order based on Westphalian sovereignty and balance of power- - Peace of Westphalia (1648) established modern sovereign state system- - Balance of power prevents hegemonic domination- - Concert of Europe managed great power relations through diplomacy- - Historical continuity from Westphalia to modern European order-- Kissinger Compliance Required: Historical continuity, diplomatic nuance, realpolitik analysis- """-- try:- # Extract current events from state- current_events = state.get('current_events', [])-- # Initialize results structure- analysis_results = {- 'westphalian_analysis': {- 'sovereignty_assessment': None,- 'border_integrity_evaluation': None,- 'non_interference_principles': None- },- 'balance_power_analysis': {- 'hegemony_threats': [],- 'coalition_opportunities': [],- 'power_equilibrium_status': None- },- 'historical_continuity': {- 'westphalian_patterns': [],- 'concert_of_europe_legacy': [],- 'diplomatic_tradition_continuity': None- },- 'diplomatic_recommendations': {- 'westphalian_solutions': [],- 'balance_power_actions': [],- 'european_coordination_opportunities': []- },- 'framework_compliance': {- 'kissinger_score': 0,- 'historical_continuity_score': 0,- 'realpolitik_application': 0- }- }-- # Process each current event through Westphalian framework- for event in current_events:- event_analysis = analyze_event_westphalian(event)-- # Update analysis results- analysis_results['westphalian_analysis']['sovereignty_assessment'] = \- event_analysis.get('sovereignty_impact')- analysis_results['balance_power_analysis']['hegemony_threats'].extend(- event_analysis.get('hegemony_threats', [])- )- analysis_results['historical_continuity']['westphalian_patterns'].extend(- event_analysis.get('historical_patterns', [])- )-- # Calculate Kissinger framework compliance- analysis_results['framework_compliance']['kissinger_score'] = \- calculate_kissinger_compliance(analysis_results)-- # Generate diplomatic recommendations- analysis_results['diplomatic_recommendations'] = \- generate_westphalian_recommendations(analysis_results)-- return analysis_results-- except Exception as e:- return {- 'error': f'Westphalian Europe agent analysis failed: {str(e)}',- 'framework': 'kissinger_world_order',- 'agent_type': 'westphalian_europe'- }--def analyze_event_westphalian(event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze current event through Westphalian framework-- Key Westphalian Principles (Kissinger Interpretation):- 1. State sovereignty - supreme authority within territory- 2. Non-interference - respect for domestic jurisdiction- 3. Balance of power - prevent any single power dominance- 4. Diplomatic equality - all states equal in international law- """-- # Extract event details- event_type = event.get('type', '')- actors = event.get('actors', [])- location = event.get('location', '')- description = event.get('description', '')-- analysis = {- 'sovereignty_impact': None,- 'hegemony_threats': [],- 'historical_patterns': [],- 'westphalian_compliance': 0- }-- # Analyze sovereignty implications- if 'border' in description.lower() or 'territory' in description.lower():- analysis['sovereignty_impact'] = 'High impact on sovereign borders'- analysis['westphalian_compliance'] += 30-- # Check for hegemony threats- if len(actors) > 2 and any('power' in actor.lower() for actor in actors):- analysis['hegemony_threats'].append('Multi-actor power competition')- analysis['westphalian_compliance'] += 25-- # Identify historical patterns- if 'conflict' in description.lower() and 'europe' in location.lower():- analysis['historical_patterns'].append('European great power competition')- analysis['westphalian_compliance'] += 25-- # Check for diplomatic solutions- if 'negotiation' in description.lower() or 'treaty' in description.lower():- analysis['historical_patterns'].append('Westphalian diplomatic tradition')- analysis['westphalian_compliance'] += 20-- return analysis--def calculate_kissinger_compliance(analysis: Dict[str, Any]) -> float:- """- Calculate compliance with Kissinger's framework requirements-- Kissinger Framework Requirements:- 1. Historical Continuity (30%): Show connection to Westphalian tradition- 2. Realpolitik Analysis (25%): Power-based calculations- 3. Diplomatic Nuance (25%): Understanding of subtle diplomacy- 4. Balance of Power Logic (20%): Equilibrium maintenance- """-- score = 0.0-- # Historical Continuity (30%)- historical_patterns = analysis.get('historical_continuity', {}).get('westphalian_patterns', [])- if len(historical_patterns) > 0:- score += 30 * min(len(historical_patterns) / 3, 1.0)-- # Realpolitik Analysis (25%)- hegemony_threats = analysis.get('balance_power_analysis', {}).get('hegemony_threats', [])- if len(hegemony_threats) > 0:- score += 25 * min(len(hegemony_threats) / 2, 1.0)-- # Diplomatic Nuance (25%) - Based on sovereignty assessment- sovereignty_analysis = analysis.get('westphalian_analysis', {}).get('sovereignty_assessment')- if sovereignty_analysis:- score += 25-- # Balance of Power Logic (20%)- equilibrium_status = analysis.get('balance_power_analysis', {}).get('power_equilibrium_status')- if equilibrium_status:- score += 20-- return min(score, 100.0)--def generate_westphalian_recommendations(analysis: Dict[str, Any]) -> Dict[str, List[str]]:- """- Generate Kissinger-style diplomatic recommendations based on Westphalian principles- """-- recommendations = {- 'westphalian_solutions': [],- 'balance_power_actions': [],- 'european_coordination_opportunities': []- }-- # Westphalian Solutions- sovereignty_impact = analysis.get('westphalian_analysis', {}).get('sovereignty_assessment')- if sovereignty_impact:- recommendations['westphalian_solutions'].extend([- 'Respect sovereign borders and territorial integrity',- 'Apply principle of non-interference in domestic affairs',- 'Seek diplomatic solutions that honor Westphalian sovereignty'- ])-- # Balance of Power Actions- hegemony_threats = analysis.get('balance_power_analysis', {}).get('hegemony_threats', [])- if hegemony_threats:- recommendations['balance_power_actions'].extend([- 'Form counterbalancing coalitions to prevent dominance',- 'Maintain equilibrium through diplomatic engagement',- 'Apply traditional European balance of power logic'- ])-- # European Coordination- historical_patterns = analysis.get('historical_continuity', {}).get('westphalian_patterns', [])- if 'European great power competition' in historical_patterns:- recommendations['european_coordination_opportunities'].extend([- 'Revive Concert of Europe-style great power consultation',- 'Use traditional European diplomatic channels',- 'Apply historical lessons from European state system'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- # Test data typical of current geopolitical events- test_events = [- {- 'type': 'border_conflict',- 'actors': ['Russia', 'Ukraine', 'NATO'],- 'location': 'Eastern Europe',- 'description': 'Conflict over territorial borders and sovereignty'- },- {- 'type': 'diplomatic_negotiation',- 'actors': ['EU', 'UK'],- 'location': 'Europe',- 'description': 'Negotiations over trade and cooperation agreement'- }- ]-- # Initialize agent state- test_state = {- 'current_events': test_events,- 'analysis_framework': 'kissinger_world_order'- }-- # Run analysis- result = westphalian_europe_agent(test_state)-- print("=== WESTPHALIAN EUROPE ORDER AGENT ANALYSIS ===")- print(f"Kissinger Framework Compliance: {result['framework_compliance']['kissinger_score']:.1f}%")- print(f"Sovereignty Assessment: {result['westphalian_analysis']['sovereignty_assessment']}")- print(f"Hegemony Threats: {len(result['balance_power_analysis']['hegemony_threats'])}")- print(f"Historical Patterns: {result['historical_continuity']['westphalian_patterns']}")- print("\nDIPLOMATIC RECOMMENDATIONS:")- for category, recs in result['diplomatic_recommendations'].items():- if recs:- print(f"\n{category.upper()}:")- for rec in recs:- print(f" - {rec}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/balance_power_calculations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/balance_power_calculations.pydeleted file mode 100644index 674e092aa..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/balance_power_calculations.py+++ /dev/null@@ -1,582 +0,0 @@-"""-BALANCE OF POWER CALCULATIONS MODULE - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - state_capabilities_data-# - alliance_formations-# - power_transition_indicators-# - regional_distributions-#-# OUTPUT:-# - Power balance assessments-# - Hegemony threat levels-# - Coalition recommendations-# - Equilibrium maintenance strategies-#-# PARAMETERS:-# - analysis_type="equilibrium_maintenance"-# - framework="kissinger_balance_power"-# - time_horizon="medium_term"-"""--from typing import Dict, List, Any, Tuple-import json-import math--class BalancePowerCalculator:- """- BALANCE OF POWER CALCULATIONS MODULE - Henry Kissinger Framework-- Core Principle: International stability requires balanced distribution of power- - Prevent emergence of hegemons through counterbalancing- - Maintain equilibrium through diplomatic flexibility- - Use alliance formations to shift power balance- - Apply historical lessons from European state system- """-- def __init__(self):- self.balance_thresholds = {- 'hegemony_warning': 60.0, # % of total power that triggers hegemony concern- 'balance_acceptable': 45.0, # % range considered balanced- 'power_gap_warning': 25.0, # Power gap that triggers balancing action- }-- self.historical_precedents = {- 'concert_of_europe': {- 'period': '1815-1914',- 'mechanism': 'Great power cooperation',- 'success_rate': 0.75- },- 'bismarckian_system': {- 'period': '1871-1890',- 'mechanism': 'Complex alliance networks',- 'success_rate': 0.80- },- 'cold_war_balance': {- 'period': '1947-1991',- 'mechanism': 'Nuclear deterrence',- 'success_rate': 0.85- }- }-- def calculate_power_balance(self, actors: List[Dict[str, Any]]) -> Dict[str, Any]:- """- Calculate comprehensive power balance among actors-- Kissinger Balance of Power Analysis:- 1. Assess relative capabilities of all actors- 2. Identify potential hegemons- 3. Calculate balancing requirements- 4. Recommend coalition strategies- """-- # Calculate comprehensive power scores- power_assessments = self._assess_actor_capabilities(actors)-- # Analyze power distribution- distribution_analysis = self._analyze_power_distribution(power_assessments)-- # Identify hegemony threats- hegemony_analysis = self._identify_hegemony_threats(power_assessments, distribution_analysis)-- # Calculate balancing requirements- balancing_needs = self._calculate_balancing_requirements(power_assessments, hegemony_analysis)-- # Generate equilibrium strategies- equilibrium_strategies = self._generate_equilibrium_strategies(- power_assessments, hegemony_analysis, balancing_needs- )-- return {- 'power_assessments': power_assessments,- 'distribution_analysis': distribution_analysis,- 'hegemony_analysis': hegemony_analysis,- 'balancing_needs': balancing_needs,- 'equilibrium_strategies': equilibrium_strategies,- 'historical_precedents': self._apply_historical_precedents(distribution_analysis),- 'stability_assessment': self._assess_overall_stability(distribution_analysis, hegemony_analysis)- }-- def _assess_actor_capabilities(self, actors: List[Dict[str, Any]]) -> List[Dict[str, Any]]:- """Assess comprehensive power capabilities of each actor"""-- power_factors = {- 'military': {'weight': 0.35, 'factors': ['personnel', 'equipment', 'technology', 'nuclear']},- 'economic': {'weight': 0.30, 'factors': ['gdp', 'trade', 'technology', 'resources']},- 'political': {'weight': 0.20, 'factors': ['leadership', 'institutions', 'cohesion', 'alliances']},- 'geographic': {'weight': 0.15, 'factors': ['location', 'size', 'resources', 'access']}- }-- assessments = []-- for actor in actors:- actor_name = actor.get('name', 'Unknown')- actor_capabilities = actor.get('capabilities', {})-- category_scores = {}- total_score = 0.0-- for category, config in power_factors.items():- category_score = 0.0- category_data = actor_capabilities.get(category, {})-- # Calculate score for each factor in category- factor_scores = []- for factor in config['factors']:- factor_value = category_data.get(factor, 0)- # Normalize to 0-100 scale- normalized_value = min(max(factor_value, 0), 100)- factor_scores.append(normalized_value)-- # Category score is average of factors- if factor_scores:- category_score = sum(factor_scores) / len(factor_scores)-- category_scores[category] = category_score- total_score += category_score * config['weight']-- assessment = {- 'name': actor_name,- 'category_scores': category_scores,- 'total_power_score': total_score,- 'power_rank': None, # Will be calculated after all actors assessed- 'balancing_needs': {}- }-- assessments.append(assessment)-- # Rank actors by power- assessments.sort(key=lambda x: x['total_power_score'], reverse=True)- for i, assessment in enumerate(assessments):- assessment['power_rank'] = i + 1-- return assessments-- def _analyze_power_distribution(self, power_assessments: List[Dict[str, Any]]) -> Dict[str, Any]:- """Analyze overall distribution of power"""-- if not power_assessments:- return {'distribution_type': 'no_data', 'analysis': 'No power data available'}-- total_power = sum(assessment['total_power_score'] for assessment in power_assessments)- top_power = power_assessments[0]['total_power_score']- top_power_percentage = (top_power / total_power) * 100 if total_power > 0 else 0-- # Analyze power gaps- power_gaps = []- for i in range(len(power_assessments) - 1):- current_power = power_assessments[i]['total_power_score']- next_power = power_assessments[i + 1]['total_power_score']- gap = current_power - next_power- gap_percentage = (gap / current_power) * 100 if current_power > 0 else 0-- power_gaps.append({- 'rank_gap': f"{i+1} to {i+2}",- 'power_gap': gap,- 'gap_percentage': gap_percentage,- 'significance': self._assess_gap_significance(gap_percentage)- })-- # Determine distribution type- distribution_type = self._classify_distribution_type(- top_power_percentage, len(power_assessments), power_gaps- )-- return {- 'distribution_type': distribution_type,- 'total_power': total_power,- 'top_power_percentage': top_power_percentage,- 'power_gaps': power_gaps,- 'concentration_index': self._calculate_concentration_index(power_assessments),- 'balance_quality': self._assess_balance_quality(power_assessments)- }-- def _assess_gap_significance(self, gap_percentage: float) -> str:- """Assess significance of power gaps"""- if gap_percentage > 50:- return 'very_large'- elif gap_percentage > 30:- return 'large'- elif gap_percentage > 15:- return 'medium'- elif gap_percentage > 5:- return 'small'- else:- return 'minimal'-- def _classify_distribution_type(self, top_power_percentage: float,- num_actors: int, power_gaps: List[Dict[str, Any]]) -> str:- """Classify the type of power distribution"""-- if top_power_percentage > self.balance_thresholds['hegemony_warning']:- return 'hegemonic_dominance'- elif top_power_percentage > self.balance_thresholds['balance_acceptable']:- return 'unipolar_tendencies'- elif num_actors >= 2 and len(power_gaps) > 0 and power_gaps[0]['gap_percentage'] < 20:- return 'bipolar_balance'- elif num_actors >= 3:- return 'multipolar_distribution'- else:- return 'balanced_distribution'-- def _calculate_concentration_index(self, power_assessments: List[Dict[str, Any]]) -> float:- """Calculate Herfindahl-Hirschman Index for power concentration"""- if not power_assessments:- return 0.0-- total_power = sum(assessment['total_power_score'] for assessment in power_assessments)- if total_power == 0:- return 0.0-- hhi = 0.0- for assessment in power_assessments:- market_share = assessment['total_power_score'] / total_power- hhi += market_share ** 2-- return hhi * 10000 # Scale for easier interpretation-- def _assess_balance_quality(self, power_assessments: List[Dict[str, Any]]) -> str:- """Assess overall quality of power balance"""- if len(power_assessments) < 2:- return 'insufficient_data'-- distribution_analysis = self._analyze_power_distribution(power_assessments)- concentration_index = distribution_analysis['concentration_index']-- if concentration_index > 2500:- return 'poor_balance'- elif concentration_index > 1500:- return 'moderate_balance'- elif concentration_index > 1000:- return 'good_balance'- else:- return 'excellent_balance'-- def _identify_hegemony_threats(self, power_assessments: List[Dict[str, Any]],- distribution_analysis: Dict[str, Any]) -> Dict[str, Any]:- """Identify potential hegemony threats"""-- hegemony_threats = []-- top_power_percentage = distribution_analysis.get('top_power_percentage', 0)- distribution_type = distribution_analysis.get('distribution_type', '')-- # Check for hegemonic dominance- if top_power_percentage > self.balance_thresholds['hegemony_warning']:- top_actor = power_assessments[0]- hegemony_threats.append({- 'actor': top_actor['name'],- 'threat_level': 'high',- 'power_percentage': top_power_percentage,- 'balancing_needed': True,- 'recommended_action': 'form_counterbalancing_coalition'- })-- # Check for unipolar tendencies- elif top_power_percentage > self.balance_thresholds['balance_acceptable']:- top_actor = power_assessments[0]- hegemony_threats.append({- 'actor': top_actor['name'],- 'threat_level': 'medium',- 'power_percentage': top_power_percentage,- 'balancing_needed': True,- 'recommended_action': 'monitor_and_balance'- })-- # Check for rising powers- for i, assessment in enumerate(power_assessments[1:], 1):- if assessment['total_power_score'] > 60: # Arbitrary threshold for major power- hegemony_threats.append({- 'actor': assessment['name'],- 'threat_level': 'potential',- 'power_percentage': (assessment['total_power_score'] /- sum(a['total_power_score'] for a in power_assessments)) * 100,- 'balancing_needed': False,- 'recommended_action': 'strategic_engagement'- })-- return {- 'threats_identified': hegemony_threats,- 'overall_threat_level': self._calculate_overall_threat_level(hegemony_threats),- 'balancing_requirements': self._assess_balancing_requirements(hegemony_threats)- }-- def _calculate_overall_threat_level(self, threats: List[Dict[str, Any]]) -> str:- """Calculate overall hegemony threat level"""- if not threats:- return 'low'-- high_threats = [t for t in threats if t['threat_level'] == 'high']- medium_threats = [t for t in threats if t['threat_level'] == 'medium']-- if high_threats:- return 'high'- elif len(medium_threats) > 1:- return 'medium'- elif medium_threats:- return 'low_medium'- else:- return 'low'-- def _assess_balancing_requirements(self, threats: List[Dict[str, Any]]) -> Dict[str, Any]:- """Assess balancing requirements based on identified threats"""- balancing_actors = [t['actor'] for t in threats if t['balancing_needed']]-- return {- 'balancing_needed': len(balancing_actors) > 0,- 'actors_to_balance': balancing_actors,- 'urgency_level': 'high' if any(t['threat_level'] == 'high' for t in threats) else 'medium',- 'coalition_size_required': len(balancing_actors) + 2 # Minimum coalition size- }-- def _calculate_balancing_requirements(self, power_assessments: List[Dict[str, Any]],- hegemony_analysis: Dict[str, Any]) -> Dict[str, Any]:- """Calculate specific balancing requirements"""- requirements = {- 'coalition_formations': [],- 'power_shifting_needs': [],- 'diplomatic_priorities': []- }-- threats = hegemony_analysis.get('threats_identified', [])- for threat in threats:- if threat['balancing_needed']:- target_actor = threat['actor']- # Find potential balancing partners- balancing_partners = [a for a in power_assessments if a['name'] != target_actor]-- requirements['coalition_formations'].append({- 'target': target_actor,- 'recommended_partners': [p['name'] for p in balancing_partners[:3]],- 'coalition_strength_needed': threat['power_percentage'] * 1.2- })-- return requirements-- def _generate_equilibrium_strategies(self, power_assessments: List[Dict[str, Any]],- hegemony_analysis: Dict[str, Any],- balancing_needs: Dict[str, Any]) -> List[str]:- """Generate strategies for maintaining equilibrium"""- strategies = []-- threat_level = hegemony_analysis.get('overall_threat_level', 'low')-- if threat_level == 'high':- strategies.extend([- 'Immediate formation of counterbalancing coalition',- 'Strengthen alliances with middle powers',- 'Provide security guarantees to potential balancing partners'- ])- elif threat_level == 'medium':- strategies.extend([- 'Strategic diplomatic engagement with rising powers',- 'Maintain flexible alliance options',- 'Monitor power transitions carefully'- ])- else:- strategies.extend([- 'Preserve current power distribution',- 'Strengthen international institutions',- 'Promote diplomatic conflict resolution'- ])-- # Add historical wisdom- strategies.extend([- 'Apply lessons from historical balance of power systems',- 'Maintain strategic flexibility over fixed commitments',- 'Prioritize stability over ideological considerations'- ])-- return strategies-- def _apply_historical_precedents(self, distribution_analysis: Dict[str, Any]) -> List[Dict[str, Any]]:- """Apply historical precedents to current situation"""- applicable_precedents = []-- distribution_type = distribution_analysis.get('distribution_type', '')-- for precedent_name, precedent_data in self.historical_precedents.items():- relevance = self._assess_precedent_relevance(distribution_type, precedent_name)- if relevance > 0.5:- applicable_precedents.append({- 'name': precedent_name,- 'period': precedent_data['period'],- 'mechanism': precedent_data['mechanism'],- 'success_rate': precedent_data['success_rate'],- 'relevance_score': relevance,- 'lessons_applicable': self._extract_lessons(precedent_name, distribution_type)- })-- return applicable_precedents-- def _assess_precedent_relevance(self, distribution_type: str, precedent_name: str) -> float:- """Assess relevance of historical precedent to current situation"""- relevance_map = {- 'hegemonic_dominance': {'concert_of_europe': 0.8, 'bismarckian_system': 0.7, 'cold_war_balance': 0.9},- 'bipolar_balance': {'cold_war_balance': 0.9, 'concert_of_europe': 0.6},- 'multipolar_distribution': {'concert_of_europe': 0.8, 'bismarckian_system': 0.9},- 'unipolar_tendencies': {'concert_of_europe': 0.7, 'bismarckian_system': 0.6}- }-- return relevance_map.get(distribution_type, {}).get(precedent_name, 0.3)-- def _extract_lessons(self, precedent_name: str, distribution_type: str) -> List[str]:- """Extract lessons from historical precedents"""- lessons_map = {- 'concert_of_europe': [- 'Great power cooperation essential for stability',- 'Regular diplomatic consultation prevents crises',- 'Balance of power requires mutual recognition'- ],- 'bismarckian_system': [- 'Complex alliance networks deter aggression',- 'Strategic flexibility maintains options',- 'Isolate potential revisionist powers'- ],- 'cold_war_balance': [- 'Nuclear deterrence prevents great power war',- 'Clear red lines reduce miscalculation',- 'Indirect competition manageable'- ]- }-- return lessons_map.get(precedent_name, [])-- def _assess_overall_stability(self, distribution_analysis: Dict[str, Any],- hegemony_analysis: Dict[str, Any]) -> Dict[str, Any]:- """Assess overall stability of the international system"""- threat_level = hegemony_analysis.get('overall_threat_level', 'low')- balance_quality = distribution_analysis.get('balance_quality', 'unknown')-- stability_factors = {- 'threat_level': threat_level,- 'balance_quality': balance_quality,- 'concentration_index': distribution_analysis.get('concentration_index', 0)- }-- # Calculate stability score- stability_score = 100.0- if threat_level == 'high':- stability_score -= 40- elif threat_level == 'medium':- stability_score -= 20- elif threat_level == 'low_medium':- stability_score -= 10-- if balance_quality == 'poor_balance':- stability_score -= 30- elif balance_quality == 'moderate_balance':- stability_score -= 15- elif balance_quality == 'good_balance':- stability_score -= 5-- concentration_index = distribution_analysis.get('concentration_index', 0)- if concentration_index > 2500:- stability_score -= 20- elif concentration_index > 1500:- stability_score -= 10-- stability_score = max(0, stability_score)-- return {- 'stability_score': stability_score,- 'stability_rating': self._classify_stability(stability_score),- 'stability_factors': stability_factors,- 'recommendations': self._generate_stability_recommendations(stability_score, threat_level)- }-- def _classify_stability(self, score: float) -> str:- """Classify stability based on score"""- if score >= 80:- return 'highly_stable'- elif score >= 60:- return 'moderately_stable'- elif score >= 40:- return 'vulnerable'- else:- return 'unstable'-- def _generate_stability_recommendations(self, stability_score: float, threat_level: str) -> List[str]:- """Generate recommendations for maintaining stability"""- recommendations = []-- if stability_score < 40:- recommendations.extend([- 'Urgent diplomatic intervention required',- 'Form emergency balancing coalitions',- 'Crisis management mechanisms essential'- ])- elif stability_score < 60:- recommendations.extend([- 'Strategic engagement with rising powers',- 'Strengthen alliance commitments',- 'Enhance diplomatic communication channels'- ])- else:- recommendations.extend([- 'Maintain current diplomatic arrangements',- 'Monitor power transitions carefully',- 'Preserve international institutions'- ])-- return recommendations--# Example usage and testing-if __name__ == "__main__":- calculator = BalancePowerCalculator()-- # Test data typical of balance of power analysis- test_actors = [- {- 'name': 'USA',- 'capabilities': {- 'military': {'personnel': 90, 'equipment': 95, 'technology': 95, 'nuclear': 100},- 'economic': {'gdp': 90, 'trade': 85, 'technology': 95, 'resources': 80},- 'political': {'leadership': 85, 'institutions': 90, 'cohesion': 75, 'alliances': 95},- 'geographic': {'location': 90, 'size': 85, 'resources': 85, 'access': 95}- }- },- {- 'name': 'China',- 'capabilities': {- 'military': {'personnel': 95, 'equipment': 85, 'technology': 80, 'nuclear': 70},- 'economic': {'gdp': 85, 'trade': 90, 'technology': 85, 'resources': 75},- 'political': {'leadership': 90, 'institutions': 80, 'cohesion': 85, 'alliances': 70},- 'geographic': {'location': 80, 'size': 95, 'resources': 70, 'access': 75}- }- },- {- 'name': 'Russia',- 'capabilities': {- 'military': {'personnel': 75, 'equipment': 70, 'technology': 75, 'nuclear': 95},- 'economic': {'gdp': 60, 'trade': 65, 'technology': 65, 'resources': 90},- 'political': {'leadership': 85, 'institutions': 70, 'cohesion': 80, 'alliances': 75},- 'geographic': {'location': 90, 'size': 95, 'resources': 95, 'access': 80}- }- }- ]-- result = calculator.calculate_power_balance(test_actors)-- print("=== BALANCE OF POWER CALCULATIONS ===")- print(f"Distribution Type: {result['distribution_analysis']['distribution_type']}")- print(f"Balance Quality: {result['distribution_analysis']['balance_quality']}")- print(f"Overall Stability: {result['stability_assessment']['stability_rating']}")- print(f"Stability Score: {result['stability_assessment']['stability_score']:.1f}")-- print("\nPOWER RANKINGS:")- for assessment in result['power_assessments']:- print(f" {assessment['power_rank']}. {assessment['name']}: {assessment['total_power_score']:.1f}")-- print("\nHEGEMONY THREATS:")- for threat in result['hegemony_analysis']['threats_identified']:- print(f" - {threat['actor']}: {threat['threat_level']} threat ({threat['power_percentage']:.1f}%)")-- print("\nEQUILIBRIUM STRATEGIES:")- for strategy in result['equilibrium_strategies']:- print(f" - {strategy}")-- print("\nHISTORICAL PRECEDENTS:")- for precedent in result['historical_precedents']:- print(f" - {precedent['name']}: Relevance {precedent['relevance_score']:.2f}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/realpolitik_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/realpolitik_analysis.pydeleted file mode 100644index 7fa4d864e..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/diplomatic_modules/realpolitik_analysis.py+++ /dev/null@@ -1,346 +0,0 @@-"""-REALPOLITIK ANALYSIS MODULE - Henry Kissinger Framework--===== DATA SOURCES REQUIRED =====-# INPUT:-# - geopolitical_events-# - power_distribution_data-# - national_interest_calculations-# - strategic_considerations-#-# OUTPUT:-# - Realpolitik assessments-# - Power-based recommendations-# - Interest calculations over ideology-# - Pragmatic diplomatic solutions-#-# PARAMETERS:-# - analysis_type="power_based"-# - framework="kissinger_realpolitik"-# - ideological_vs_power_balance="power_priority"-"""--from typing import Dict, List, Any, Tuple-import json--class RealpolitikAnalyzer:- """- REALPOLITIK ANALYSIS MODULE - Henry Kissinger Framework-- Core Principle: Power calculations override ideological preferences- - National interest defined in terms of power, not values- - Pragmatic solutions over moral considerations- - Balance of power considerations drive policy- - Historical experience guides current decisions- """-- def __init__(self):- self.power_factors = {- 'military_capability': 0.30,- 'economic_strength': 0.25,- 'geographic_position': 0.15,- 'diplomatic_influence': 0.15,- 'technological_advantage': 0.10,- 'resource_control': 0.05- }-- self.realpolitik_principles = {- 'power_primacy': 'Power calculations take precedence over ideology',- 'national_interest': 'Actions based on concrete national interests',- 'balance_maintenance': 'Prevent hegemonic dominance',- 'pragmatic_solutions': 'Practical over moral considerations',- 'historical_guidance': 'Use historical patterns for current decisions'- }-- def analyze_power_dynamics(self, event: Dict[str, Any]) -> Dict[str, Any]:- """- Analyze event through pure power calculation lens-- Kissinger Realpolitik Approach:- 1. Assess power distribution between actors- 2. Calculate national interest implications- 3. Identify balance of power considerations- 4. Generate pragmatic, power-based recommendations- """-- actors = event.get('actors', [])- description = event.get('description', '')-- # Calculate power scores for each actor- power_scores = self._calculate_power_scores(actors)-- # Analyze power distribution- power_analysis = self._analyze_power_distribution(power_scores)-- # Assess balance of power implications- balance_assessment = self._assess_balance_implications(power_scores, description)-- # Generate realpolitik recommendations- recommendations = self._generate_realpolitik_recommendations(- power_analysis, balance_assessment, event- )-- return {- 'power_scores': power_scores,- 'power_distribution': power_analysis,- 'balance_assessment': balance_assessment,- 'realpolitik_recommendations': recommendations,- 'ideology_vs_power': 'Power calculation prioritized',- 'framework_compliance': self._calculate_realpolitik_compliance(power_analysis, balance_assessment)- }-- def _calculate_power_scores(self, actors: List[str]) -> Dict[str, float]:- """Calculate relative power scores for actors"""-- # Power ratings based on general knowledge (simplified)- base_power_ratings = {- 'usa': 95.0, 'united states': 95.0, 'america': 95.0,- 'china': 85.0, 'prc': 85.0,- 'russia': 75.0, 'soviet union': 70.0,- 'eu': 80.0, 'european union': 80.0,- 'india': 65.0,- 'japan': 60.0,- 'uk': 55.0, 'britain': 55.0,- 'france': 50.0,- 'germany': 50.0,- 'iran': 40.0,- 'saudi arabia': 35.0,- 'israel': 40.0,- 'turkey': 35.0,- 'brazil': 35.0,- 'nigeria': 25.0,- 'pakistan': 30.0,- 'south korea': 35.0,- 'canada': 30.0,- 'australia': 25.0- }-- power_scores = {}- for actor in actors:- actor_lower = actor.lower()- # Find matching power rating- power_score = base_power_ratings.get(actor_lower, 20.0) # Default for unknown actors- power_scores[actor] = power_score-- return power_scores-- def _analyze_power_distribution(self, power_scores: Dict[str, float]) -> Dict[str, Any]:- """Analyze distribution of power among actors"""-- if not power_scores:- return {'analysis': 'No actors to analyze', 'distribution_type': 'none'}-- sorted_powers = sorted(power_scores.items(), key=lambda x: x[1], reverse=True)- total_power = sum(power_scores.values())-- # Calculate power concentration- top_actor_power = sorted_powers[0][1] if sorted_powers else 0- power_concentration = (top_actor_power / total_power) * 100 if total_power > 0 else 0-- # Determine distribution type- if power_concentration > 60:- distribution_type = 'hegemonic_dominance'- elif power_concentration > 40:- distribution_type = 'unipolar_tendencies'- elif len(sorted_powers) >= 2 and sorted_powers[0][1] - sorted_powers[1][1] < 20:- distribution_type = 'bipolar_balance'- elif len(sorted_powers) >= 3:- distribution_type = 'multipolar_distribution'- else:- distribution_type = 'balanced_distribution'-- return {- 'sorted_powers': sorted_powers,- 'total_power': total_power,- 'power_concentration': power_concentration,- 'distribution_type': distribution_type,- 'dominant_actor': sorted_powers[0][0] if sorted_powers else None,- 'power_gaps': self._calculate_power_gaps(sorted_powers)- }-- def _calculate_power_gaps(self, sorted_powers: List[Tuple[str, float]]) -> List[Dict[str, Any]]:- """Calculate power gaps between consecutive actors"""-- gaps = []- for i in range(len(sorted_powers) - 1):- current_actor, current_power = sorted_powers[i]- next_actor, next_power = sorted_powers[i + 1]- gap = current_power - next_power- gap_percentage = (gap / current_power) * 100 if current_power > 0 else 0-- gaps.append({- 'stronger_actor': current_actor,- 'weaker_actor': next_actor,- 'power_gap': gap,- 'gap_percentage': gap_percentage,- 'significance': 'large' if gap > 30 else 'medium' if gap > 15 else 'small'- })-- return gaps-- def _assess_balance_implications(self, power_scores: Dict[str, float], description: str) -> Dict[str, Any]:- """Assess implications for balance of power"""-- power_analysis = self._analyze_power_distribution(power_scores)- distribution_type = power_analysis['distribution_type']-- # Balance of power implications- implications = {- 'hegemony_threat': 'high' if 'hegemonic' in distribution_type else 'medium' if 'unipolar' in distribution_type else 'low',- 'stability_assessment': self._assess_stability(power_analysis),- 'coalition_needs': self._assess_coalition_needs(power_analysis),- 'power_transition_risk': self._assess_power_transition_risk(power_analysis)- }-- # Event-specific implications- event_implications = []- if 'conflict' in description.lower():- event_implications.append('Power calculations critical in conflict resolution')- if 'cooperation' in description.lower():- event_implications.append('Power balance affects cooperation prospects')- if 'alliance' in description.lower():- event_implications.append('Alliance formations shift power distribution')-- implications['event_specific'] = event_implications-- return implications-- def _assess_stability(self, power_analysis: Dict[str, Any]) -> str:- """Assess stability based on power distribution"""-- distribution_type = power_analysis['distribution_type']- power_concentration = power_analysis['power_concentration']-- if distribution_type == 'hegemonic_dominance':- return 'unstable_due_to_resistance'- elif distribution_type == 'unipolar_tendencies':- return 'moderately_stable_with_challenges'- elif distribution_type == 'bipolar_balance':- return 'stable_with_rivalry_tensions'- elif distribution_type == 'multipolar_distribution':- return 'complex_stability_with_shifting_alliances'- else:- return 'relatively_stable'-- def _assess_coalition_needs(self, power_analysis: Dict[str, Any]) -> List[str]:- """Assess coalition-building needs"""-- needs = []- distribution_type = power_analysis['distribution_type']- dominant_actor = power_analysis.get('dominant_actor')-- if 'hegemonic' in distribution_type:- needs.append(f'Anti-{dominant_actor} coalition needed')- elif 'unipolar' in distribution_type:- needs.append('Balancing coalition formation')- elif 'multipolar' in distribution_type:- needs.append('Flexible coalition arrangements')-- return needs-- def _assess_power_transition_risk(self, power_analysis: Dict[str, Any]) -> str:- """Assess risk of power transition conflicts"""-- power_gaps = power_analysis.get('power_gaps', [])-- large_gaps = [gap for gap in power_gaps if gap['significance'] == 'large']- medium_gaps = [gap for gap in power_gaps if gap['significance'] == 'medium']-- if len(large_gaps) > 0:- return 'low_risk_clear_hierarchy'- elif len(medium_gaps) > 2:- return 'high_risk_multiple_contenders'- elif len(medium_gaps) > 0:- return 'medium_risk_competition_likely'- else:- return 'low_risk_stable_hierarchy'-- def _generate_realpolitik_recommendations(self, power_analysis: Dict[str, Any],- balance_assessment: Dict[str, Any],- event: Dict[str, Any]) -> List[str]:- """Generate recommendations based on pure power calculations"""-- recommendations = []- distribution_type = power_analysis['distribution_type']- dominance_threat = balance_assessment['hegemony_threat']-- # Power-based recommendations- if dominance_threat == 'high':- recommendations.append('Form counterbalancing coalition against dominant power')- recommendations.append('Support rising powers to maintain equilibrium')-- if distribution_type == 'multipolar_distribution':- recommendations.append('Maintain diplomatic flexibility with multiple partners')- recommendations.append('Balance relationships among competing powers')-- if dominance_threat == 'low':- recommendations.append('Preserve current power distribution')- recommendations.append('Use diplomatic engagement to maintain stability')-- # Event-specific recommendations- description = event.get('description', '').lower()- if 'conflict' in description:- recommendations.append('Prioritize power interests over moral considerations')- if 'cooperation' in description:- recommendations.append('Assess cooperation benefits for power enhancement')-- # Classic realpolitik principles- recommendations.extend([- 'Focus on concrete national interests rather than ideological goals',- 'Use balance of power logic as primary analytical tool',- 'Maintain strategic flexibility in diplomatic relationships'- ])-- return recommendations-- def _calculate_realpolitik_compliance(self, power_analysis: Dict[str, Any],- balance_assessment: Dict[str, Any]) -> float:- """Calculate compliance with Kissinger's realpolitik framework"""-- score = 0.0-- # Power Analysis (40%)- if power_analysis.get('distribution_type') != 'none':- score += 40-- # Balance Assessment (30%)- if balance_assessment.get('hegemony_threat'):- score += 30-- # Pragmatic Focus (20%)- # This would be assessed based on recommendations- score += 20-- # Historical Continuity (10%)- # This would be assessed based on use of historical patterns- score += 10-- return score--# Example usage and testing-if __name__ == "__main__":- analyzer = RealpolitikAnalyzer()-- # Test event typical of power politics- test_event = {- 'type': 'great_power_competition',- 'actors': ['USA', 'China', 'Russia'],- 'location': 'Indo-Pacific',- 'description': 'Competition for influence and strategic positioning'- }-- result = analyzer.analyze_power_dynamics(test_event)-- print("=== REALPOLITIK ANALYSIS ===")- print(f"Power Distribution: {result['power_distribution']['distribution_type']}")- print(f"Hegemony Threat: {result['balance_assessment']['hegemony_threat']}")- print(f"Stability Assessment: {result['balance_assessment']['stability_assessment']}")- print("\nPOWER SCORES:")- for actor, score in result['power_scores'].items():- print(f" {actor}: {score}")-- print("\nREALPOLITIK RECOMMENDATIONS:")- for rec in result['realpolitik_recommendations']:- print(f" - {rec}")-- print(f"\nFramework Compliance: {result['framework_compliance']:.1f}%")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/islamic_order_test.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/islamic_order_test.pydeleted file mode 100644index 11b78bc71..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/islamic_order_test.py+++ /dev/null@@ -1,451 +0,0 @@-"""-ISLAMIC ORDER AGENT TEST SUITE - Henry Kissinger Framework--===== TESTING FRAMEWORK =====-# INPUT:-# - dummy_islamic_world_events-# - religious_political_test_cases-# - islamic_civilization_checks-#-# OUTPUT:-# - Islamic framework validation-# - Ummah unity analysis verification-# - Religious authority assessment-# - Historical continuity from Islamic traditions-#-# PARAMETERS:-# - test_type="islamic_civilization"-# - compliance_threshold="70%"-# - validation_depth="thorough"-"""--import sys-import os-import json-from typing import Dict, List, Any--# Add the parent directories to the path-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))--from civilization_agents.islamic_world_agent import islamic_world_agent--class IslamicOrderTestSuite:- """- TEST SUITE FOR ISLAMIC ORDER AGENT- Validates agent performance against Kissinger's Islamic world order framework- """-- def __init__(self):- self.test_cases = self._initialize_test_cases()- self.compliance_threshold = 70.0- self.test_results = []-- def _initialize_test_cases(self) -> List[Dict[str, Any]]:- """Initialize comprehensive test cases for Islamic order analysis"""-- return [- {- 'name': 'Ummah Unity Test',- 'description': 'Test agent analysis of Muslim community unity beyond state boundaries',- 'events': [- {- 'type': 'islamic_cooperation',- 'actors': ['Saudi_Arabia', 'Iran', 'Turkey', 'Muslim_communities'],- 'location': 'Middle_East',- 'description': 'Islamic countries discussing pan-Islamic cooperation and unity',- 'date': '2024-01-20'- }- ],- 'expected_framework_elements': [- 'ummah_unity',- 'transnational_islamic_community',- 'religious_bonds',- 'community_beyond_borders'- ],- 'min_compliance_score': 70.0- },- {- 'name': 'Religious-Political Authority Test',- 'description': 'Test agent understanding of Islamic religious-political dynamics',- 'events': [- {- 'type': 'religious_political_dynamics',- 'actors': ['Muslim_Brotherhood', 'Egyptian_Government', 'Religious_authorities'],- 'location': 'Egypt',- 'description': 'Tensions between religious authority and state power in governance',- 'date': '2024-02-15'- }- ],- 'expected_framework_elements': [- 'religious_authority',- 'political_islam',- 'state_religion_balance',- 'islamic_governance'- ],- 'min_compliance_score': 75.0- },- {- 'name': 'Caliphate Tradition Test',- 'description': 'Test agent recognition of caliphate tradition influence',- 'events': [- {- 'type': 'islamic_governance_discussion',- 'actors': ['Islamic_movements', 'Regional_governments', 'Religious_scholars'],- 'location': 'Various_Muslim_countries',- 'description': 'Discussions about Islamic governance models and historical caliphate',- 'date': '2024-03-10'- }- ],- 'expected_framework_elements': [- 'caliphate_legacy',- 'historical_islamic_order',- 'traditional_governance',- 'islamic_political_theory'- ],- 'min_compliance_score': 70.0- },- {- 'name': 'Dar al-Islam vs Dar al-Harb Test',- 'description': 'Test agent understanding of traditional Islamic worldview',- 'events': [- {- 'type': 'islamic_worldview_analysis',- 'actors': ['Muslim_countries', 'Non_muslim_powers', 'International_community'],- 'location': 'Global',- 'description': 'Analysis of Islamic world relations with non-Islamic world',- 'date': '2024-04-05'- }- ],- 'expected_framework_elements': [- 'dar_al_islam_concept',- 'islamic_worldview',- 'civilizational_distinctions',- 'traditional_categories'- ],- 'min_compliance_score': 75.0- },- {- 'name': 'Sharia Law Influence Test',- 'description': 'Test agent analysis of Islamic legal framework influence',- 'events': [- {- 'type': 'islamic_legal_framework',- 'actors': ['Islamic_states', 'Legal_scholars', 'Reform_movements'],- 'location': 'Muslim_world',- 'description': 'Implementation and modernization of Islamic legal systems',- 'date': '2024-05-12'- }- ],- 'expected_framework_elements': [- 'sharia_law',- 'islamic_legal_traditions',- 'religious_legitimacy',- 'legal_frameworks'- ],- 'min_compliance_score': 70.0- }- ]-- def run_all_tests(self) -> Dict[str, Any]:- """Run all test cases and return comprehensive results"""- print("=== ISLAMIC ORDER AGENT TEST SUITE ===")- print(f"Running {len(self.test_cases)} test cases...\n")-- overall_results = {- 'total_tests': len(self.test_cases),- 'passed_tests': 0,- 'failed_tests': 0,- 'average_compliance': 0.0,- 'framework_validation': {},- 'test_details': []- }-- total_compliance = 0.0-- for i, test_case in enumerate(self.test_cases, 1):- print(f"Test {i}/{len(self.test_cases)}: {test_case['name']}")- print(f"Description: {test_case['description']}")-- # Run the test case- test_result = self._run_single_test(test_case)- self.test_results.append(test_result)-- # Update overall results- if test_result['passed']:- overall_results['passed_tests'] += 1- print(f"✅ PASSED (Compliance: {test_result['compliance_score']:.1f}%)")- else:- overall_results['failed_tests'] += 1- print(f"❌ FAILED (Compliance: {test_result['compliance_score']:.1f}%)")- print(f" Issues: {', '.join(test_result['missing_elements'])}")-- total_compliance += test_result['compliance_score']- print()-- # Calculate overall statistics- overall_results['average_compliance'] = total_compliance / len(self.test_cases)- overall_results['success_rate'] = (overall_results['passed_tests'] / overall_results['total_tests']) * 100-- # Validate framework compliance- overall_results['framework_validation'] = self._validate_islamic_framework_compliance()-- return overall_results-- def _run_single_test(self, test_case: Dict[str, Any]) -> Dict[str, Any]:- """Run a single test case and return results"""- events = test_case['events']- expected_elements = test_case['expected_framework_elements']- min_compliance = test_case['min_compliance_score']-- # Initialize test state- test_state = {- 'current_events': events,- 'analysis_framework': 'kissinger_world_order',- 'test_mode': True,- 'civilization_focus': 'islamic'- }-- # Run the Islamic World agent- try:- agent_result = islamic_world_agent(test_state)-- # Calculate compliance score- compliance_score = agent_result.get('framework_compliance', {}).get('kissinger_score', 0.0)-- # Check for expected framework elements- result_elements = self._extract_framework_elements(agent_result)- missing_elements = [elem for elem in expected_elements if elem not in result_elements]-- # Validate Islamic framework requirements- framework_validation = self._validate_islamic_requirements(agent_result)-- # Test passed if compliance meets threshold and required elements present- passed = (compliance_score >= min_compliance and len(missing_elements) == 0)-- return {- 'test_name': test_case['name'],- 'passed': passed,- 'compliance_score': compliance_score,- 'expected_elements': expected_elements,- 'found_elements': result_elements,- 'missing_elements': missing_elements,- 'framework_validation': framework_validation,- 'agent_result': agent_result- }-- except Exception as e:- return {- 'test_name': test_case['name'],- 'passed': False,- 'compliance_score': 0.0,- 'error': str(e),- 'expected_elements': expected_elements,- 'found_elements': [],- 'missing_elements': expected_elements- }-- def _extract_framework_elements(self, agent_result: Dict[str, Any]) -> List[str]:- """Extract Islamic framework elements from agent result"""- elements = []-- # Check for Islamic order analysis- if agent_result.get('islamic_order_analysis'):- elements.append('islamic_framework')- if agent_result['islamic_order_analysis'].get('ummah_unity_assessment'):- elements.append('ummah_unity')- if agent_result['islamic_order_analysis'].get('caliphate_tradition_influence'):- elements.append('caliphate_legacy')-- # Check for regional dynamics- if agent_result.get('regional_dynamics'):- elements.append('regional_dynamics')- if agent_result['regional_dynamics'].get('islamic_state_relations'):- elements.append('islamic_state_relations')-- # Check for historical continuity- if agent_result.get('historical_continuity'):- elements.append('historical_continuity')- if any('caliphate' in str(pattern).lower()- for pattern in agent_result['historical_continuity'].get('caliphate_legacy', [])):- elements.append('caliphate_legacy')-- # Check for diplomatic recommendations- if agent_result.get('diplomatic_recommendations'):- elements.append('diplomatic_recommendations')- recommendations = agent_result['diplomatic_recommendations']- if recommendations.get('islamic_framework_solutions'):- elements.append('islamic_solutions')-- # Check for specific Islamic concepts- result_str = json.dumps(agent_result).lower()- if 'ummah' in result_str:- elements.append('ummah_unity')- if 'caliphate' in result_str:- elements.append('caliphate_legacy')- if 'sharia' in result_str:- elements.append('sharia_law')- if 'dar al-islam' in result_str or 'dar al' in result_str:- elements.append('dar_al_islam_concept')- if 'religious authority' in result_str:- elements.append('religious_authority')- if 'islamic' in result_str:- elements.append('islamic_framework')- if 'transnational' in result_str:- elements.append('transnational_islamic_community')-- return list(set(elements)) # Remove duplicates-- def _validate_islamic_requirements(self, agent_result: Dict[str, Any]) -> Dict[str, bool]:- """Validate specific Islamic framework requirements"""- validation = {- 'islamic_cultural_understanding': False,- 'historical_continuity_present': False,- 'religious_political_analysis': False,- 'ummah_concept_understanding': False,- 'regional_dynamics_analysis': False- }-- # Check Islamic cultural understanding- if agent_result.get('islamic_order_analysis'):- validation['islamic_cultural_understanding'] = True-- # Check historical continuity- if agent_result.get('historical_continuity', {}).get('caliphate_legacy'):- validation['historical_continuity_present'] = True-- # Check religious-political analysis- if agent_result.get('regional_dynamics', {}).get('religious_political_balance'):- validation['religious_political_analysis'] = True-- # Check Ummah concept understanding- ummah_assessment = agent_result.get('islamic_order_analysis', {}).get('ummah_unity_assessment')- if ummah_assessment:- validation['ummah_concept_understanding'] = True-- # Check regional dynamics analysis- if agent_result.get('regional_dynamics', {}).get('islamic_state_relations'):- validation['regional_dynamics_analysis'] = True-- return validation-- def _validate_islamic_framework_compliance(self) -> Dict[str, Any]:- """Validate overall Islamic framework compliance across all tests"""- validation_summary = {- 'islamic_framework_compliance': 0.0,- 'cultural_understanding_score': 0.0,- 'historical_continuity_score': 0.0,- 'religious_political_score': 0.0,- 'ummah_concept_score': 0.0,- 'overall_framework_health': 'unknown'- }-- if not self.test_results:- return validation_summary-- # Calculate average scores for each framework component- total_tests = len(self.test_results)- cultural_count = 0- historical_count = 0- religious_count = 0- ummah_count = 0-- for result in self.test_results:- if result.get('framework_validation'):- validation = result['framework_validation']- if validation.get('islamic_cultural_understanding'):- cultural_count += 1- if validation.get('historical_continuity_present'):- historical_count += 1- if validation.get('religious_political_analysis'):- religious_count += 1- if validation.get('ummah_concept_understanding'):- ummah_count += 1-- validation_summary['cultural_understanding_score'] = (cultural_count / total_tests) * 100- validation_summary['historical_continuity_score'] = (historical_count / total_tests) * 100- validation_summary['religious_political_score'] = (religious_count / total_tests) * 100- validation_summary['ummah_concept_score'] = (ummah_count / total_tests) * 100-- # Calculate overall framework health- framework_scores = [- validation_summary['cultural_understanding_score'],- validation_summary['historical_continuity_score'],- validation_summary['religious_political_score'],- validation_summary['ummah_concept_score']- ]-- validation_summary['islamic_framework_compliance'] = sum(framework_scores) / len(framework_scores)-- if validation_summary['islamic_framework_compliance'] >= 80:- validation_summary['overall_framework_health'] = 'excellent'- elif validation_summary['islamic_framework_compliance'] >= 70:- validation_summary['overall_framework_health'] = 'good'- elif validation_summary['islamic_framework_compliance'] >= 60:- validation_summary['overall_framework_health'] = 'fair'- else:- validation_summary['overall_framework_health'] = 'poor'-- return validation_summary-- def generate_test_report(self, results: Dict[str, Any]) -> str:- """Generate comprehensive test report"""- report = []- report.append("=" * 60)- report.append("ISLAMIC ORDER AGENT TEST REPORT")- report.append("=" * 60)- report.append(f"Total Tests: {results['total_tests']}")- report.append(f"Passed: {results['passed_tests']}")- report.append(f"Failed: {results['failed_tests']}")- report.append(f"Success Rate: {results['success_rate']:.1f}%")- report.append(f"Average Compliance: {results['average_compliance']:.1f}%")- report.append("")-- # Framework validation summary- framework_validation = results['framework_validation']- report.append("ISLAMIC FRAMEWORK VALIDATION SUMMARY:")- report.append(f" Islamic Framework Compliance: {framework_validation['islamic_framework_compliance']:.1f}%")- report.append(f" Cultural Understanding: {framework_validation['cultural_understanding_score']:.1f}%")- report.append(f" Historical Continuity: {framework_validation['historical_continuity_score']:.1f}%")- report.append(f" Religious-Political Analysis: {framework_validation['religious_political_score']:.1f}%")- report.append(f" Ummah Concept Understanding: {framework_validation['ummah_concept_score']:.1f}%")- report.append(f" Overall Framework Health: {framework_validation['overall_framework_health'].upper()}")- report.append("")-- # Individual test details- report.append("INDIVIDUAL TEST RESULTS:")- for i, test_detail in enumerate(results['test_details'], 1):- report.append(f" {i}. {test_detail['test_name']}")- report.append(f" Status: {'PASSED' if test_detail['passed'] else 'FAILED'}")- report.append(f" Compliance: {test_detail['compliance_score']:.1f}%")- if test_detail.get('missing_elements'):- report.append(f" Missing Elements: {', '.join(test_detail['missing_elements'])}")- report.append("")-- # Recommendations- report.append("RECOMMENDATIONS:")- if results['average_compliance'] < 70:- report.append(" - Agent needs significant improvement to meet Islamic framework standards")- report.append(" - Focus on Islamic cultural and historical understanding")- report.append(" - Strengthen religious-political dynamics analysis")- elif results['average_compliance'] < 80:- report.append(" - Agent performs adequately but could be enhanced")- report.append(" - Consider adding more Islamic historical context")- report.append(" - Refine Ummah concept analysis")- else:- report.append(" - Agent demonstrates strong Islamic framework compliance")- report.append(" - Ready for production deployment")- report.append(" - Consider additional Islamic civilization testing")-- return "\n".join(report)--# Example usage and testing-if __name__ == "__main__":- # Initialize and run test suite- test_suite = IslamicOrderTestSuite()- results = test_suite.run_all_tests()-- # Generate and display report- report = test_suite.generate_test_report(results)- print(report)-- print(f"\nTest suite completed. Overall readiness: {'PRODUCTION READY' if results['average_compliance'] >= 70 else 'NEEDS IMPROVEMENT'}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/westphalian_order_test.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/westphalian_order_test.pydeleted file mode 100644index e4e899856..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/World_Order_Agents/test_agents/westphalian_order_test.py+++ /dev/null@@ -1,488 +0,0 @@-"""-WESTPHALIAN ORDER AGENT TEST SUITE - Henry Kissinger Framework--===== TESTING FRAMEWORK =====-# INPUT:-# - dummy_geopolitical_events-# - historical_test_cases-# - framework_compliance_checks-#-# OUTPUT:-# - Agent performance validation-# - Kissinger framework compliance score-# - Historical continuity verification-# - Diplomatic nuance assessment-#-# PARAMETERS:-# - test_type="comprehensive"-# - compliance_threshold="70%"-# - validation_depth="thorough"-"""--import sys-import os-import json-from typing import Dict, List, Any--# Add the parent directories to the path-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))--from civilization_agents.westphalian_europe_agent import westphalian_europe_agent-from diplomatic_modules.realpolitik_analysis import RealpolitikAnalyzer-from diplomatic_modules.balance_power_calculations import BalancePowerCalculator--class WestphalianOrderTestSuite:- """- TEST SUITE FOR WESTPHALIAN ORDER AGENT- Validates agent performance against Kissinger's framework requirements- """-- def __init__(self):- self.test_cases = self._initialize_test_cases()- self.compliance_threshold = 70.0- self.test_results = []-- def _initialize_test_cases(self) -> List[Dict[str, Any]]:- """Initialize comprehensive test cases for Westphalian order analysis"""-- return [- {- 'name': 'Sovereignty Crisis Test',- 'description': 'Test agent analysis of sovereignty violations',- 'events': [- {- 'type': 'border_conflict',- 'actors': ['Russia', 'Ukraine', 'NATO'],- 'location': 'Eastern Europe',- 'description': 'Conflict over territorial borders and sovereign boundaries',- 'date': '2024-01-15'- }- ],- 'expected_framework_elements': [- 'sovereignty_assessment',- 'westphalian_principles',- 'border_integrity',- 'non_interference'- ],- 'min_compliance_score': 70.0- },- {- 'name': 'Balance of Power Test',- 'description': 'Test agent ability to analyze European balance dynamics',- 'events': [- {- 'type': 'great_power_competition',- 'actors': ['Germany', 'France', 'UK'],- 'location': 'Europe',- 'description': 'European powers managing regional balance and cooperation',- 'date': '2024-02-20'- }- ],- 'expected_framework_elements': [- 'balance_power',- 'hegemony_prevention',- 'equilibrium_maintenance',- 'concert_of_europe'- ],- 'min_compliance_score': 75.0- },- {- 'name': 'Diplomatic Tradition Test',- 'description': 'Test agent understanding of European diplomatic continuity',- 'events': [- {- 'type': 'diplomatic_negotiation',- 'actors': ['EU', 'UK', 'European_States'],- 'location': 'Brussels',- 'description': 'Traditional European diplomatic negotiations and treaty-making',- 'date': '2024-03-10'- }- ],- 'expected_framework_elements': [- 'historical_continuity',- 'diplomatic_protocols',- 'westphalian_traditions',- 'european_coordination'- ],- 'min_compliance_score': 70.0- },- {- 'name': 'Multi-actor Crisis Test',- 'description': 'Test complex multi-actor European crisis analysis',- 'events': [- {- 'type': 'regional_crisis',- 'actors': ['NATO', 'EU', 'Russia', 'Multiple_European_States'],- 'location': 'Eastern Europe',- 'description': 'Complex crisis involving multiple actors and alliance systems',- 'date': '2024-04-05'- }- ],- 'expected_framework_elements': [- 'alliance_systems',- 'coalition_formations',- 'crisis_diplomacy',- 'security_guarantees'- ],- 'min_compliance_score': 75.0- },- {- 'name': 'Historical Pattern Recognition Test',- 'description': 'Test agent recognition of historical European patterns',- 'events': [- {- 'type': 'power_transition',- 'actors': ['European_Powers', 'Rising_Powers'],- 'location': 'Europe',- 'description': 'Power transition patterns reminiscent of historical European changes',- 'date': '2024-05-12'- }- ],- 'expected_framework_elements': [- 'historical_patterns',- 'power_transition_dynamics',- 'european_state_system',- 'balance_powershifts'- ],- 'min_compliance_score': 80.0- }- ]-- def run_all_tests(self) -> Dict[str, Any]:- """Run all test cases and return comprehensive results"""- print("=== WESTPHALIAN ORDER AGENT TEST SUITE ===")- print(f"Running {len(self.test_cases)} test cases...\n")-- overall_results = {- 'total_tests': len(self.test_cases),- 'passed_tests': 0,- 'failed_tests': 0,- 'average_compliance': 0.0,- 'framework_validation': {},- 'test_details': []- }-- total_compliance = 0.0-- for i, test_case in enumerate(self.test_cases, 1):- print(f"Test {i}/{len(self.test_cases)}: {test_case['name']}")- print(f"Description: {test_case['description']}")-- # Run the test case- test_result = self._run_single_test(test_case)- self.test_results.append(test_result)-- # Update overall results- if test_result['passed']:- overall_results['passed_tests'] += 1- print(f"✅ PASSED (Compliance: {test_result['compliance_score']:.1f}%)")- else:- overall_results['failed_tests'] += 1- print(f"❌ FAILED (Compliance: {test_result['compliance_score']:.1f}%)")- print(f" Issues: {', '.join(test_result['missing_elements'])}")-- total_compliance += test_result['compliance_score']- print()-- # Calculate overall statistics- overall_results['average_compliance'] = total_compliance / len(self.test_cases)- overall_results['success_rate'] = (overall_results['passed_tests'] / overall_results['total_tests']) * 100-- # Validate framework compliance- overall_results['framework_validation'] = self._validate_framework_compliance()-- return overall_results-- def _run_single_test(self, test_case: Dict[str, Any]) -> Dict[str, Any]:- """Run a single test case and return results"""- events = test_case['events']- expected_elements = test_case['expected_framework_elements']- min_compliance = test_case['min_compliance_score']-- # Initialize test state- test_state = {- 'current_events': events,- 'analysis_framework': 'kissinger_world_order',- 'test_mode': True- }-- # Run the Westphalian Europe agent- try:- agent_result = westphalian_europe_agent(test_state)-- # Calculate compliance score- compliance_score = agent_result.get('framework_compliance', {}).get('kissinger_score', 0.0)-- # Check for expected framework elements- result_elements = self._extract_framework_elements(agent_result)- missing_elements = [elem for elem in expected_elements if elem not in result_elements]-- # Validate Kissinger framework requirements- framework_validation = self._validate_kissinger_requirements(agent_result)-- # Test passed if compliance meets threshold and required elements present- passed = (compliance_score >= min_compliance and len(missing_elements) == 0)-- return {- 'test_name': test_case['name'],- 'passed': passed,- 'compliance_score': compliance_score,- 'expected_elements': expected_elements,- 'found_elements': result_elements,- 'missing_elements': missing_elements,- 'framework_validation': framework_validation,- 'agent_result': agent_result- }-- except Exception as e:- return {- 'test_name': test_case['name'],- 'passed': False,- 'compliance_score': 0.0,- 'error': str(e),- 'expected_elements': expected_elements,- 'found_elements': [],- 'missing_elements': expected_elements- }-- def _extract_framework_elements(self, agent_result: Dict[str, Any]) -> List[str]:- """Extract framework elements from agent result"""- elements = []-- # Check for Westphalian sovereignty analysis- if agent_result.get('westphalian_analysis'):- elements.append('sovereignty_assessment')- if agent_result['westphalian_analysis'].get('sovereignty_impact'):- elements.append('border_integrity')-- # Check for balance of power analysis- if agent_result.get('balance_power_analysis'):- elements.append('balance_power')- if agent_result['balance_power_analysis'].get('hegemony_threats'):- elements.append('hegemony_prevention')-- # Check for historical continuity- if agent_result.get('historical_continuity'):- elements.append('historical_continuity')- if any('westphalian' in str(pattern).lower()- for pattern in agent_result['historical_continuity'].get('westphalian_patterns', [])):- elements.append('westphalian_traditions')-- # Check for diplomatic recommendations- if agent_result.get('diplomatic_recommendations'):- elements.append('diplomatic_recommendations')- recommendations = agent_result['diplomatic_recommendations']- if recommendations.get('westphalian_solutions'):- elements.append('westphalian_solutions')-- # Check for specific Westphalian concepts- result_str = json.dumps(agent_result).lower()- if 'sovereign' in result_str:- elements.append('sovereignty')- if 'non-interference' in result_str:- elements.append('non_interference')- if 'diplomatic' in result_str:- elements.append('diplomatic_protocols')-- return list(set(elements)) # Remove duplicates-- def _validate_kissinger_requirements(self, agent_result: Dict[str, Any]) -> Dict[str, bool]:- """Validate specific Kissinger framework requirements"""- validation = {- 'historical_continuity_present': False,- 'realpolitik_analysis_present': False,- 'diplomatic_nuance_present': False,- 'balance_power_logic_present': False,- 'european_understanding_present': False- }-- # Check historical continuity- if agent_result.get('historical_continuity', {}).get('westphalian_patterns'):- validation['historical_continuity_present'] = True-- # Check realpolitik analysis- if agent_result.get('balance_power_analysis', {}).get('hegemony_threats'):- validation['realpolitik_analysis_present'] = True-- # Check diplomatic nuance- if agent_result.get('diplomatic_recommendations'):- validation['diplomatic_nuance_present'] = True-- # Check balance of power logic- power_analysis = agent_result.get('balance_power_analysis', {})- if power_analysis.get('hegemony_threats') or power_analysis.get('power_equilibrium_status'):- validation['balance_power_logic_present'] = True-- # Check European understanding- result_str = json.dumps(agent_result).lower()- if any(term in result_str for term in ['europe', 'westphalian', 'concert', 'sovereign']):- validation['european_understanding_present'] = True-- return validation-- def _validate_framework_compliance(self) -> Dict[str, Any]:- """Validate overall framework compliance across all tests"""- validation_summary = {- 'kissinger_framework_compliance': 0.0,- 'historical_continuity_score': 0.0,- 'realpolitik_application_score': 0.0,- 'diplomatic_nuance_score': 0.0,- 'european_expertise_score': 0.0,- 'overall_framework_health': 'unknown'- }-- if not self.test_results:- return validation_summary-- # Calculate average scores for each framework component- total_tests = len(self.test_results)- historical_count = 0- realpolitik_count = 0- diplomatic_count = 0- european_count = 0-- for result in self.test_results:- if result.get('framework_validation'):- validation = result['framework_validation']- if validation.get('historical_continuity_present'):- historical_count += 1- if validation.get('realpolitik_analysis_present'):- realpolitik_count += 1- if validation.get('diplomatic_nuance_present'):- diplomatic_count += 1- if validation.get('european_understanding_present'):- european_count += 1-- validation_summary['historical_continuity_score'] = (historical_count / total_tests) * 100- validation_summary['realpolitik_application_score'] = (realpolitik_count / total_tests) * 100- validation_summary['diplomatic_nuance_score'] = (diplomatic_count / total_tests) * 100- validation_summary['european_expertise_score'] = (european_count / total_tests) * 100-- # Calculate overall framework health- framework_scores = [- validation_summary['historical_continuity_score'],- validation_summary['realpolitik_application_score'],- validation_summary['diplomatic_nuance_score'],- validation_summary['european_expertise_score']- ]-- validation_summary['kissinger_framework_compliance'] = sum(framework_scores) / len(framework_scores)-- if validation_summary['kissinger_framework_compliance'] >= 80:- validation_summary['overall_framework_health'] = 'excellent'- elif validation_summary['kissinger_framework_compliance'] >= 70:- validation_summary['overall_framework_health'] = 'good'- elif validation_summary['kissinger_framework_compliance'] >= 60:- validation_summary['overall_framework_health'] = 'fair'- else:- validation_summary['overall_framework_health'] = 'poor'-- return validation_summary-- def generate_test_report(self, results: Dict[str, Any]) -> str:- """Generate comprehensive test report"""- report = []- report.append("=" * 60)- report.append("WESTPHALIAN ORDER AGENT TEST REPORT")- report.append("=" * 60)- report.append(f"Total Tests: {results['total_tests']}")- report.append(f"Passed: {results['passed_tests']}")- report.append(f"Failed: {results['failed_tests']}")- report.append(f"Success Rate: {results['success_rate']:.1f}%")- report.append(f"Average Compliance: {results['average_compliance']:.1f}%")- report.append("")-- # Framework validation summary- framework_validation = results['framework_validation']- report.append("FRAMEWORK VALIDATION SUMMARY:")- report.append(f" Kissinger Framework Compliance: {framework_validation['kissinger_framework_compliance']:.1f}%")- report.append(f" Historical Continuity: {framework_validation['historical_continuity_score']:.1f}%")- report.append(f" Realpolitik Application: {framework_validation['realpolitik_application_score']:.1f}%")- report.append(f" Diplomatic Nuance: {framework_validation['diplomatic_nuance_score']:.1f}%")- report.append(f" European Expertise: {framework_validation['european_expertise_score']:.1f}%")- report.append(f" Overall Framework Health: {framework_validation['overall_framework_health'].upper()}")- report.append("")-- # Individual test details- report.append("INDIVIDUAL TEST RESULTS:")- for i, test_detail in enumerate(results['test_details'], 1):- report.append(f" {i}. {test_detail['test_name']}")- report.append(f" Status: {'PASSED' if test_detail['passed'] else 'FAILED'}")- report.append(f" Compliance: {test_detail['compliance_score']:.1f}%")- if test_detail.get('missing_elements'):- report.append(f" Missing Elements: {', '.join(test_detail['missing_elements'])}")- report.append("")-- # Recommendations- report.append("RECOMMENDATIONS:")- if results['average_compliance'] < 70:- report.append(" - Agent needs significant improvement to meet Kissinger framework standards")- report.append(" - Focus on historical continuity and European diplomatic traditions")- report.append(" - Strengthen realpolitik analysis components")- elif results['average_compliance'] < 80:- report.append(" - Agent performs adequately but could be enhanced")- report.append(" - Consider adding more European historical context")- report.append(" - Refine diplomatic nuance in recommendations")- else:- report.append(" - Agent demonstrates strong Kissinger framework compliance")- report.append(" - Ready for production deployment")- report.append(" - Consider additional edge case testing")-- return "\n".join(report)--# Example usage and testing-if __name__ == "__main__":- # Initialize and run test suite- test_suite = WestphalianOrderTestSuite()- results = test_suite.run_all_tests()-- # Generate and display report- report = test_suite.generate_test_report(results)- print(report)-- # Additional validation with diplomatic modules- print("\n" + "=" * 60)- print("ADDITIONAL DIPLOMATIC MODULES TESTING")- print("=" * 60)-- # Test Realpolitik Analyzer- print("\nTesting Realpolitik Analysis Module:")- realpolitik_analyzer = RealpolitikAnalyzer()- test_event = {- 'type': 'sovereignty_conflict',- 'actors': ['Russia', 'Ukraine', 'NATO'],- 'location': 'Eastern Europe',- 'description': 'Conflict over territorial sovereignty and international borders'- }- realpolitik_result = realpolitik_analyzer.analyze_power_dynamics(test_event)- print(f"Power Distribution: {realpolitik_result['power_distribution']['distribution_type']}")- print(f"Framework Compliance: {realpolitik_result['framework_compliance']:.1f}%")-- # Test Balance Power Calculator- print("\nTesting Balance of Power Calculator:")- balance_calculator = BalancePowerCalculator()- test_actors = [- {- 'name': 'NATO',- 'capabilities': {- 'military': {'personnel': 85, 'equipment': 90, 'technology': 95, 'nuclear': 100},- 'economic': {'gdp': 80, 'trade': 85, 'technology': 90, 'resources': 75},- 'political': {'leadership': 80, 'institutions': 85, 'cohesion': 70, 'alliances': 95},- 'geographic': {'location': 85, 'size': 80, 'resources': 75, 'access': 90}- }- },- {- 'name': 'Russia',- 'capabilities': {- 'military': {'personnel': 75, 'equipment': 70, 'technology': 75, 'nuclear': 95},- 'economic': {'gdp': 60, 'trade': 65, 'technology': 65, 'resources': 90},- 'political': {'leadership': 85, 'institutions': 70, 'cohesion': 80, 'alliances': 75},- 'geographic': {'location': 90, 'size': 95, 'resources': 95, 'access': 80}- }- }- ]- balance_result = balance_calculator.calculate_power_balance(test_actors)- print(f"Balance Quality: {balance_result['distribution_analysis']['balance_quality']}")- print(f"Stability Assessment: {balance_result['stability_assessment']['stability_rating']}")-- print(f"\nTest suite completed. Overall readiness: {'PRODUCTION READY' if results['average_compliance'] >= 70 else 'NEEDS IMPROVEMENT'}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/configs/agent_definitions.json b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/configs/agent_definitions.jsonindex 8a1c034bf..3471dc0cc 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/configs/agent_definitions.json+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/configs/agent_definitions.json@@ -5,7 +5,7 @@"name": "Russia Geographic Analysis","role": "Geographic determinism analyst for Russia","goal": "Analyze geopolitical events through the lens of Russia's geographic constraints and advantages",- "description": "Specializes in analyzing Russian geopolitical strategy based on Tim Marshall's 'Prisoners of Geography' framework - focus on plains vulnerability, warm-water port access, and buffer zone strategy.",+ "description": "📖 Prisoners of Geography | Plains vulnerability, warm-water ports, buffer zones","llm_config": {"provider": "openai","model_id": "gpt-4-turbo",@@ -15,14 +15,15 @@"tools": ["web_search", "news_analysis"],"enable_memory": true,"enable_agentic_memory": true,- "instructions": "You are a geopolitical analyst specializing in Russian affairs through the lens of geographic determinism. Analyze events considering: 1) Russia's lack of natural barriers on its western plains, 2) Historical need for buffer zones, 3) Strategic importance of warm-water ports (Crimea, Syria), 4) Resource distribution across vast territory. Always ground your analysis in geographic realities that constrain Russian policy options."+ "instructions": "You are a geopolitical analyst specializing in Russian affairs through the lens of geographic determinism. Analyze events considering: 1) Russia's lack of natural barriers on its western plains, 2) Historical need for buffer zones, 3) Strategic importance of warm-water ports (Crimea, Syria), 4) Resource distribution across vast territory. Always ground your analysis in geographic realities that constrain Russian policy options.",+ "book_source": "Prisoners of Geography"},{"id": "prisoners_geography_china","name": "China Geographic Analysis","role": "Geographic determinism analyst for China","goal": "Analyze Chinese geopolitical strategy through geographic constraints",- "description": "Specializes in analyzing Chinese geopolitical moves based on geographic realities - maritime vulnerability, Himalayan barriers, internal unity challenges, and island chain strategy.",+ "description": "📖 Prisoners of Geography | Maritime vulnerability, Himalayas, island chains","llm_config": {"provider": "openai","model_id": "gpt-4-turbo",@@ -32,14 +33,119 @@"tools": ["web_search", "news_analysis"],"enable_memory": true,"enable_agentic_memory": true,- "instructions": "You are a geopolitical analyst specializing in Chinese affairs through geographic determinism. Analyze events considering: 1) China's maritime vulnerability and dependence on sea lanes, 2) The Himalayan barrier protecting from the south, 3) Internal unity challenges across diverse regions, 4) The first and second island chain strategies, 5) Belt and Road as geographic power projection. Always explain how geography shapes China's strategic imperatives."+ "instructions": "You are a geopolitical analyst specializing in Chinese affairs through geographic determinism. Analyze events considering: 1) China's maritime vulnerability and dependence on sea lanes, 2) The Himalayan barrier protecting from the south, 3) Internal unity challenges across diverse regions, 4) The first and second island chain strategies, 5) Belt and Road as geographic power projection. Always explain how geography shapes China's strategic imperatives.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_usa",+ "name": "USA Geographic Analysis",+ "role": "Geographic determinism analyst for United States",+ "goal": "Analyze how USA's geography enables global power projection",+ "description": "📖 Prisoners of Geography | Ocean barriers, Mississippi River, temperate climate, no land threats",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze USA's geographic advantages: Atlantic/Pacific oceans, Mississippi River, temperate climate, weak neighbors. Explain isolationism → continental dominance → global hegemony.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_europe",+ "name": "Europe Geographic Analysis",+ "role": "Geographic determinism analyst for Europe",+ "goal": "Analyze how Europe's geography created division and maritime power",+ "description": "📖 Prisoners of Geography | Fragmented terrain, navigable rivers, peninsular position",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Europe's fragmentation: Alps/Pyrenees create nations, Rhine/Danube trade routes, peninsulas → maritime. Connect to EU integration.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_middle_east",+ "name": "Middle East Geographic Analysis",+ "role": "Geographic determinism analyst for Middle East",+ "goal": "Analyze how Middle East geography creates perpetual instability",+ "description": "📖 Prisoners of Geography | Deserts, oil fields, artificial borders, water scarcity",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Middle East: Sykes-Picot borders ignore geography, oil concentrations, water scarcity, desert barriers, choke points (Suez, Hormuz).",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_africa",+ "name": "Africa Geographic Analysis",+ "role": "Geographic determinism analyst for Africa",+ "goal": "Analyze how Africa's geography hinders development",+ "description": "📖 Prisoners of Geography | Non-navigable rivers, Sahara barrier, colonial borders",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Africa: waterfalls block rivers, Sahara divides continent, colonial borders ignore tribes, landlocked nations, resource curse.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_india_pakistan",+ "name": "India-Pakistan Geographic Analysis",+ "role": "Geographic determinism analyst for Indian subcontinent",+ "goal": "Analyze how geography shapes India-Pakistan rivalry",+ "description": "📖 Prisoners of Geography | Himalayas, Indus/Ganges rivers, partition water disputes",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze India-Pakistan: Himalayas, Indus River partition, Kashmir water source, 1947 partition ignored water geography.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_japan_korea",+ "name": "Japan-Korea Geographic Analysis",+ "role": "Geographic determinism analyst for Japan and Korea",+ "goal": "Analyze island/peninsula geography and strategic competition",+ "description": "📖 Prisoners of Geography | Island isolation vs peninsula vulnerability",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Japan-Korea: island isolation → maritime power, peninsula → invasions, resource scarcity, alliance patterns (Japan-US, NK-China).",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_latin_america",+ "name": "Latin America Geographic Analysis",+ "role": "Geographic determinism analyst for Latin America",+ "goal": "Analyze how geography prevents regional integration",+ "description": "📖 Prisoners of Geography | Andes, Amazon, fragmentation limits unity",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Latin America: Andes divide Pacific/Atlantic, Amazon blocks north-south, Panama choke point, landlocked Bolivia, prevents EU-style unity.",+ "book_source": "Prisoners of Geography"+ },+ {+ "id": "prisoners_geography_arctic",+ "name": "Arctic Geographic Analysis",+ "role": "Geographic determinism analyst for Arctic region",+ "goal": "Analyze how Arctic geography reshapes great power competition",+ "description": "📖 Prisoners of Geography | Melting ice, new shipping routes, resource access",+ "llm_config": {"provider": "openai", "model_id": "gpt-4-turbo", "temperature": 0.7, "max_tokens": 3000},+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Arctic transformation: ice melt → Northern Sea Route, resource access, territorial claims (Russia, Canada, Denmark, Norway, US), new competition zone.",+ "book_source": "Prisoners of Geography"},{"id": "world_order_american","name": "American World Order Analysis","role": "Kissinger's American world order analyst","goal": "Analyze events through the framework of American liberal internationalism",- "description": "Analyzes geopolitical events using Henry Kissinger's framework of American world order - emphasizing democratic values, liberal internationalism, and American exceptionalism.",+ "description": "📖 World Order (Kissinger) | Liberal internationalism, democratic values, American exceptionalism","llm_config": {"provider": "anthropic","model_id": "claude-3-sonnet-20240229",@@ -49,14 +155,15 @@"tools": ["web_search", "news_analysis"],"enable_memory": true,"enable_agentic_memory": true,- "instructions": "You are a geopolitical analyst using Henry Kissinger's framework of American world order. Analyze events through: 1) Liberal internationalist principles, 2) Democratic value promotion, 3) American exceptionalism and global leadership, 4) Balance between idealism and realpolitik, 5) Post-WWII institutional framework (UN, NATO, etc.). Assess how events align with or challenge American-led international order."+ "instructions": "You are a geopolitical analyst using Henry Kissinger's framework of American world order. Analyze events through: 1) Liberal internationalist principles, 2) Democratic value promotion, 3) American exceptionalism and global leadership, 4) Balance between idealism and realpolitik, 5) Post-WWII institutional framework (UN, NATO, etc.). Assess how events align with or challenge American-led international order.",+ "book_source": "World Order"},{"id": "world_order_chinese","name": "Chinese World Order Analysis","role": "Kissinger's Chinese world order analyst","goal": "Analyze events through the framework of Chinese world order concepts",- "description": "Analyzes geopolitical events using Kissinger's framework of Chinese world order - emphasizing hierarchical relationships, tributary system concepts, and Middle Kingdom centrality.",+ "description": "📖 World Order (Kissinger) | Tributary system, Middle Kingdom, Confucian governance","llm_config": {"provider": "anthropic","model_id": "claude-3-sonnet-20240229",@@ -66,14 +173,141 @@"tools": ["web_search", "news_analysis"],"enable_memory": true,"enable_agentic_memory": true,- "instructions": "You are a geopolitical analyst using Kissinger's framework of Chinese world order. Analyze events through: 1) Historical tributary system and hierarchical relationships, 2) Middle Kingdom centrality in East Asian order, 3) Confucian governance principles, 4) Long-term strategic patience, 5) Harmony and stability over confrontation. Assess how China's historical world view shapes modern foreign policy and Belt & Road Initiative."+ "instructions": "You are a geopolitical analyst using Kissinger's framework of Chinese world order. Analyze events through: 1) Historical tributary system and hierarchical relationships, 2) Middle Kingdom centrality in East Asian order, 3) Confucian governance principles, 4) Long-term strategic patience, 5) Harmony and stability over confrontation. Assess how China's historical world view shapes modern foreign policy and Belt & Road Initiative.",+ "book_source": "World Order"+ },+ {+ "id": "world_order_european",+ "name": "European World Order Analysis",+ "role": "Kissinger's European balance of power analyst",+ "goal": "Analyze events through Westphalian system and European balance of power",+ "description": "📖 World Order (Kissinger) | Westphalian sovereignty, balance of power, European concert",+ "llm_config": {+ "provider": "anthropic",+ "model_id": "claude-3-sonnet-20240229",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze through Westphalian system: 1) State sovereignty principles from Peace of Westphalia, 2) Balance of power mechanics, 3) Concert of Europe diplomacy, 4) Modern EU as post-Westphalian experiment, 5) Tension between national sovereignty and supranational integration.",+ "book_source": "World Order"+ },+ {+ "id": "world_order_islamic",+ "name": "Islamic World Order Analysis",+ "role": "Kissinger's Islamic world order analyst",+ "goal": "Analyze events through Islamic concepts of world order",+ "description": "📖 World Order (Kissinger) | Ummah, Caliphate legacy, Sharia governance",+ "llm_config": {+ "provider": "anthropic",+ "model_id": "claude-3-sonnet-20240229",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze Islamic world order concepts: 1) Ummah (global Muslim community), 2) Historical Caliphate system, 3) Tension between Islamic law and Westphalian sovereignty, 4) Arab Spring and legitimacy crises, 5) Sectarian divisions (Sunni-Shia).",+ "book_source": "World Order"+ },+ {+ "id": "world_order_multipolar",+ "name": "Multipolar World Order Analysis",+ "role": "Kissinger's multipolar system analyst",+ "goal": "Analyze transition from unipolar to multipolar world order",+ "description": "📖 World Order (Kissinger) | Rise of new powers, declining hegemony, regional orders",+ "llm_config": {+ "provider": "anthropic",+ "model_id": "claude-3-sonnet-20240229",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze multipolar transition: 1) Decline of American unipolarity, 2) Rise of China, India, Brazil, 3) Regional hegemons, 4) Clash of legitimacy principles, 5) Nuclear proliferation and new power centers.",+ "book_source": "World Order"},{"id": "grand_chessboard_eurasian","name": "Eurasian Balkans Analysis","role": "Brzezinski's Eurasian Balkans analyst","goal": "Analyze Central Asian geopolitics through the Grand Chessboard framework",- "description": "Specializes in analyzing Central Asian and Caucasus geopolitics using Zbigniew Brzezinski's 'Grand Chessboard' framework - focus on pivotal regions, strategic instability, and great power competition.",+ "description": "📖 The Grand Chessboard (Brzezinski) | Pivotal regions, strategic instability, great power competition",+ "llm_config": {+ "provider": "openai",+ "model_id": "gpt-4-turbo",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "You are a geopolitical analyst using Brzezinski's 'Grand Chessboard' framework for Eurasian Balkans. Analyze events in Central Asia and Caucasus considering: 1) The region as a pivotal geopolitical space, 2) Competition between Russia, China, and the West for influence, 3) Energy resources and pipeline politics, 4) Ethnic and religious fault lines creating instability, 5) Buffer zone dynamics. Always assess great power positioning in this critical region.",+ "book_source": "The Grand Chessboard"+ },+ {+ "id": "grand_chessboard_pivots",+ "name": "Geopolitical Pivots Analysis",+ "role": "Brzezinski's geopolitical pivots analyst",+ "goal": "Analyze pivotal states that can tip balance of power in Eurasia",+ "description": "📖 The Grand Chessboard (Brzezinski) | Ukraine, Turkey, Iran as pivots, strategic positioning",+ "llm_config": {+ "provider": "openai",+ "model_id": "gpt-4-turbo",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze geopolitical pivots per Brzezinski: 1) Ukraine as critical pivot between Russia and Europe, 2) Turkey's gateway position, 3) Iran's role in Middle East-Central Asia nexus, 4) How pivot states' alignments shift regional balance, 5) Great power competition for pivot influence.",+ "book_source": "The Grand Chessboard"+ },+ {+ "id": "grand_chessboard_players",+ "name": "Active Geostrategic Players Analysis",+ "role": "Brzezinski's active players analyst",+ "goal": "Analyze states with capacity to project power beyond borders",+ "description": "📖 The Grand Chessboard (Brzezinski) | France, Germany, Russia, China, India as active players",+ "llm_config": {+ "provider": "openai",+ "model_id": "gpt-4-turbo",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze active geostrategic players: 1) States with power projection capabilities, 2) Revisionist vs status quo powers, 3) Regional hegemons (Russia, China, India), 4) European players (France, Germany, UK), 5) How active players shape Eurasian chessboard.",+ "book_source": "The Grand Chessboard"+ },+ {+ "id": "grand_chessboard_american_primacy",+ "name": "American Primacy Analysis",+ "role": "Brzezinski's American global primacy analyst",+ "goal": "Analyze American strategy to maintain primacy in Eurasia",+ "description": "📖 The Grand Chessboard (Brzezinski) | US hegemony, preventing Eurasian challenger, alliance management",+ "llm_config": {+ "provider": "openai",+ "model_id": "gpt-4-turbo",+ "temperature": 0.7,+ "max_tokens": 3000+ },+ "tools": ["web_search", "news_analysis"],+ "enable_memory": true,+ "enable_agentic_memory": true,+ "instructions": "Analyze US primacy strategy per Brzezinski: 1) Preventing rise of peer competitor in Eurasia, 2) Managing European-Russian-Chinese triangle, 3) NATO expansion, 4) Energy security and pipeline diplomacy, 5) Democratic enlargement vs realpolitik.",+ "book_source": "The Grand Chessboard"+ },+ {+ "id": "grand_chessboard_eurasia_heartland",+ "name": "Eurasian Heartland Analysis",+ "role": "Brzezinski's Eurasian heartland analyst",+ "goal": "Analyze Mackinder's Heartland theory in modern context",+ "description": "📖 The Grand Chessboard (Brzezinski) | Heartland theory, pivot area, control of Eurasia","llm_config": {"provider": "openai","model_id": "gpt-4-turbo",@@ -83,7 +317,8 @@"tools": ["web_search", "news_analysis"],"enable_memory": true,"enable_agentic_memory": true,- "instructions": "You are a geopolitical analyst using Brzezinski's 'Grand Chessboard' framework for Eurasian Balkans. Analyze events in Central Asia and Caucasus considering: 1) The region as a pivotal geopolitical space, 2) Competition between Russia, China, and the West for influence, 3) Energy resources and pipeline politics, 4) Ethnic and religious fault lines creating instability, 5) Buffer zone dynamics. Always assess great power positioning in this critical region."+ "instructions": "Analyze through Mackinder-Brzezinski lens: 1) 'Who rules East Europe commands Heartland', 2) Control of Central Asian pivot, 3) Russia-China potential alliance threat, 4) Western strategy to prevent Eurasian integration, 5) New Silk Road implications.",+ "book_source": "The Grand Chessboard"}]}diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/geopolitics_agent_cli.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/geopolitics_agent_cli.pydeleted file mode 100644index 4e4e3830a..000000000--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/GeopoliticsAgents/geopolitics_agent_cli.py+++ /dev/null@@ -1,300 +0,0 @@-#!/usr/bin/env python3-"""-Geopolitics Agent CLI - Unified Interface-Analyzes events through book-based geopolitical frameworks-"""--import sys-import json-import argparse-from typing import Dict, Any, List-import random--# Geopolitical Framework Definitions--GEOGRAPHY_AGENTS = {- "russia_geography": {- "name": "Russia Geography",- "framework": "Prisoners of Geography (Tim Marshall)",- "focus": "North European Plain vulnerability, warm-water ports, vast territory",- "constraints": ["flat_invasion_route", "ice_bound_ports", "vast_territory", "limited_arable_land"]- },- "china_geography": {- "name": "China Geography",- "framework": "Prisoners of Geography (Tim Marshall)",- "focus": "Maritime vulnerability, unity challenges, Himalayan barrier",- "constraints": ["sea_lane_dependence", "regional_fragmentation", "mountain_barriers", "desert_isolation"]- },- "usa_geography": {- "name": "USA Geography",- "framework": "Prisoners of Geography (Tim Marshall)",- "focus": "Geographic advantages, natural moats, resource abundance",- "constraints": ["atlantic_pacific_protection", "fertile_heartland", "navigable_rivers", "weak_neighbors"]- },- "europe_geography": {- "name": "Europe Geography",- "framework": "Prisoners of Geography (Tim Marshall)",- "focus": "Fragmentation vs integration, mountain/river barriers",- "constraints": ["geographic_fragmentation", "multiple_powers", "resource_distribution", "access_barriers"]- },- "middle_east_geography": {- "name": "Middle East Geography",- "framework": "Prisoners of Geography (Tim Marshall)",- "focus": "Desert geography, resource concentration, artificial borders",- "constraints": ["desert_isolation", "resource_curse", "colonial_borders", "water_scarcity"]- }-}--WORLD_ORDER_AGENTS = {- "american_world": {- "name": "American World Order",- "framework": "World Order (Henry Kissinger)",- "focus": "Liberal internationalism, democratic values, exceptionalism",- "principles": ["universal_values", "democratic_promotion", "rule_based_order", "alliance_systems"]- },- "chinese_world": {- "name": "Chinese World Order",- "framework": "World Order (Henry Kissinger)",- "focus": "Middle Kingdom centrality, hierarchical relationships, tributary system",- "principles": ["hierarchical_order", "cultural_superiority", "harmonious_relations", "regional_leadership"]- },- "balance_power": {- "name": "Balance of Power",- "framework": "World Order (Henry Kissinger)",- "focus": "Equilibrium maintenance, power transitions, realpolitik",- "principles": ["power_equilibrium", "prevent_hegemony", "flexible_alliances", "pragmatic_diplomacy"]- },- "islamic_world": {- "name": "Islamic World Order",- "framework": "World Order (Henry Kissinger)",- "focus": "Ummah unity, Sharia-based governance, historical caliphate legacy",- "principles": ["religious_unity", "sharia_governance", "anti_colonialism", "pan_islamic_identity"]- },- "nuclear_order": {- "name": "Nuclear Order",- "framework": "World Order (Henry Kissinger)",- "focus": "Deterrence theory, arms control, nuclear diplomacy",- "principles": ["mutual_destruction", "deterrence_stability", "arms_control", "proliferation_prevention"]- }-}--CHESSBOARD_AGENTS = {- "eurasian_balkans": {- "name": "Eurasian Balkans",- "framework": "Grand Chessboard (Brzezinski)",- "focus": "Pivotal region between powers, strategic instability",- "characteristics": ["geopolitical_rivalry", "ethnic_complexity", "resource_competition", "power_vacuum"]- },- "democratic_bridgehead": {- "name": "Democratic Bridgehead",- "framework": "Grand Chessboard (Brzezinski)",- "focus": "Western influence projection into Eurasia",- "characteristics": ["democratic_values", "western_integration", "geopolitical_anchor", "reform_catalyst"]- },- "far_eastern_anchor": {- "name": "Far Eastern Anchor",- "framework": "Grand Chessboard (Brzezinski)",- "focus": "US-Japan alliance as Pacific stability pillar",- "characteristics": ["alliance_strength", "regional_stability", "power_projection", "economic_integration"]- }-}--def analyze_geography_framework(agent_type: str, event_data: Dict[str, Any], previous_context: str = None) -> Dict[str, Any]:- """Analyze through Tim Marshall's geographic determinism"""-- agent_info = GEOGRAPHY_AGENTS.get(agent_type, {})- constraints = agent_info.get("constraints", [])-- random.seed(sum(ord(c) for c in event_data.get("event", "default")))-- # Simulate geographic constraint analysis- constraint_scores = {constraint: random.uniform(0.4, 0.9) for constraint in constraints}- total_constraint = sum(constraint_scores.values()) / len(constraint_scores) if constraint_scores else 0.5-- geographic_determinism_score = random.uniform(0.65, 0.95)- strategic_imperative_score = random.uniform(0.60, 0.90)-- context_note = f"\n\n🔗 Building on Previous Context:\n{previous_context[:300]}..." if previous_context else ""-- return {- "agent": agent_info.get("name"),- "framework": agent_info.get("framework"),- "focus_area": agent_info.get("focus"),- "analysis": f"""-{agent_info.get('name')} Geographic Analysis-{context_note}--📍 Geographic Determinism Framework: {geographic_determinism_score:.1%} compliance--Geographic Constraints:-{chr(10).join(f" • {constraint.replace('_', ' ').title()}: {score:.1%} influence" for constraint, score in constraint_scores.items())}--Strategic Imperatives (Marshall's Core Thesis):- ✓ Geographic constraints DETERMINE foreign policy choices- ✓ Historical patterns repeat due to immutable geography- ✓ Strategic behavior follows geographic logic, not ideology--Overall Constraint Level: {total_constraint:.1%}-Strategic Imperative Strength: {strategic_imperative_score:.1%}--"Geography is the mother of strategy" - Tim Marshall- """.strip(),- "geographic_determinism_score": round(geographic_determinism_score, 3),- "constraint_analysis": constraint_scores,- "strategic_imperative_score": round(strategic_imperative_score, 3),- "framework_compliance": round((geographic_determinism_score + strategic_imperative_score) / 2, 3)- }--def analyze_world_order_framework(agent_type: str, event_data: Dict[str, Any], previous_context: str = None) -> Dict[str, Any]:- """Analyze through Kissinger's world order framework"""-- agent_info = WORLD_ORDER_AGENTS.get(agent_type, {})- principles = agent_info.get("principles", [])-- random.seed(sum(ord(c) for c in event_data.get("event", "default")))-- principle_scores = {principle: random.uniform(0.5, 0.95) for principle in principles}- realpolitik_score = random.uniform(0.65, 0.92)- balance_of_power_score = random.uniform(0.60, 0.88)-- context_note = f"\n\n🔗 Building on Previous Context:\n{previous_context[:300]}..." if previous_context else ""-- return {- "agent": agent_info.get("name"),- "framework": agent_info.get("framework"),- "focus_area": agent_info.get("focus"),- "analysis": f"""-{agent_info.get('name')} Order Analysis-{context_note}--🌐 Kissinger World Order Framework: {realpolitik_score:.1%} compliance--Civilizational Principles:-{chr(10).join(f" • {principle.replace('_', ' ').title()}: {score:.1%} strength" for principle, score in principle_scores.items())}--Realpolitik Analysis:- ✓ Balance of power considerations central to order- ✓ Historical continuity from civilizational traditions- ✓ Diplomatic practice reflects cultural worldview--Realpolitik Score: {realpolitik_score:.1%}-Balance of Power Score: {balance_of_power_score:.1%}--"The test of policy is how it ends, not how it begins" - Henry Kissinger- """.strip(),- "realpolitik_score": round(realpolitik_score, 3),- "principle_analysis": principle_scores,- "balance_of_power_score": round(balance_of_power_score, 3),- "framework_compliance": round((realpolitik_score + balance_of_power_score) / 2, 3)- }--def analyze_chessboard_framework(agent_type: str, event_data: Dict[str, Any], previous_context: str = None) -> Dict[str, Any]:- """Analyze through Brzezinski's grand chessboard framework"""-- agent_info = CHESSBOARD_AGENTS.get(agent_type, {})- characteristics = agent_info.get("characteristics", [])-- random.seed(sum(ord(c) for c in event_data.get("event", "default")))-- char_scores = {char: random.uniform(0.55, 0.90) for char in characteristics}- geostrategic_score = random.uniform(0.65, 0.93)- eurasian_centrality_score = random.uniform(0.60, 0.88)-- context_note = f"\n\n🔗 Building on Previous Context:\n{previous_context[:300]}..." if previous_context else ""-- return {- "agent": agent_info.get("name"),- "framework": agent_info.get("framework"),- "focus_area": agent_info.get("focus"),- "analysis": f"""-{agent_info.get('name')} Geostrategic Analysis-{context_note}--♟️ Brzezinski Grand Chessboard Framework: {geostrategic_score:.1%} compliance--Strategic Characteristics:-{chr(10).join(f" • {char.replace('_', ' ').title()}: {score:.1%} relevance" for char, score in char_scores.items())}--Eurasian Pivotal Analysis:- ✓ Geographic centrality to global power distribution- ✓ Resource concentration and transit importance- ✓ Multi-power competition and influence projection--Geostrategic Importance: {geostrategic_score:.1%}-Eurasian Centrality: {eurasian_centrality_score:.1%}--"Eurasia is the chessboard on which the struggle for global primacy continues" - Zbigniew Brzezinski- """.strip(),- "geostrategic_score": round(geostrategic_score, 3),- "characteristic_analysis": char_scores,- "eurasian_centrality_score": round(eurasian_centrality_score, 3),- "framework_compliance": round((geostrategic_score + eurasian_centrality_score) / 2, 3)- }--def execute_agent(parameters: Dict[str, Any], inputs: Dict[str, Any]) -> Dict[str, Any]:- """Main geopolitics agent execution"""- try:- agent_type = parameters.get("agent_type", "russia_geography")- event = parameters.get("event", "Current geopolitical situation")- framework = parameters.get("framework", "auto") # auto, geography, world_order, chessboard-- event_data = {"event": event}-- # Extract mediated context- mediated_context = None- if inputs and isinstance(inputs, dict):- mediated_context = inputs.get("mediated_analysis")-- # Auto-detect framework if needed- if framework == "auto":- if agent_type in GEOGRAPHY_AGENTS:- framework = "geography"- elif agent_type in WORLD_ORDER_AGENTS:- framework = "world_order"- elif agent_type in CHESSBOARD_AGENTS:- framework = "chessboard"- else:- framework = "geography" # default-- # Route to appropriate framework analyzer- if framework == "geography":- result = analyze_geography_framework(agent_type, event_data, mediated_context)- elif framework == "world_order":- result = analyze_world_order_framework(agent_type, event_data, mediated_context)- elif framework == "chessboard":- result = analyze_chessboard_framework(agent_type, event_data, mediated_context)- else:- return {"success": False, "error": f"Unknown framework: {framework}"}-- response = {- "success": True,- "agent_type": agent_type,- "framework": framework,- "event_analyzed": event,- **result- }-- if mediated_context:- response["used_previous_context"] = True-- return response-- except Exception as e:- return {"success": False, "error": str(e), "agent": "geopolitics"}--def main():- parser = argparse.ArgumentParser(description='Geopolitics Agent - Book-Based Analysis')- parser.add_argument('--parameters', type=str, required=True)- parser.add_argument('--inputs', type=str, required=True)- args = parser.parse_args()-- try:- result = execute_agent(json.loads(args.parameters), json.loads(args.inputs))- print(json.dumps(result, indent=2))- sys.exit(0)- except Exception as e:- print(json.dumps({"success": False, "error": str(e), "agent": "geopolitics"}), file=sys.stderr)- sys.exit(1)--if __name__ == "__main__":- main()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/base_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/base_agent.pyindex 6f1f788de..082bfb0c2 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/base_agent.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/base_agent.py@@ -34,6 +34,7 @@ class AgentRegistry:def __init__(self, config_path: Optional[Path] = None):self.config_path = config_pathself.agents: Dict[str, AgentConfig] = {}+ self.config_data: Dict[str, Any] = {}if config_path and config_path.exists():self.load_configs_from_json(config_path)@@ -44,6 +45,8 @@ class AgentRegistry:with open(json_path, 'r', encoding='utf-8') as f:data = json.load(f)+ self.config_data = data # Store full config including team_name+agents_list = data.get('agents', [])for agent_dict in agents_list:agent_config = AgentConfig(agent_dict)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/llm_executor.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/llm_executor.pynew file mode 100644index 000000000..938d7e4d0--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/llm_executor.py@@ -0,0 +1,267 @@+"""+LLM Executor - Real LLM API execution for agents+Supports OpenAI, Anthropic, Google Gemini, and local Ollama+"""++import json+from typing import Dict, Any, Optional+++class LLMExecutor:+ """Execute agent queries using real LLM APIs"""++ def __init__(self, api_keys: Dict[str, str]):+ self.api_keys = api_keys++ def execute(self, agent_config: Dict, query: str) -> Dict[str, Any]:+ """+ Execute agent with real LLM API++ Args:+ agent_config: Agent configuration dict+ query: User query++ Returns:+ Dict with response and metadata+ """+ llm_config = agent_config.get("llm_config", {})+ provider = llm_config.get("provider", "openai").lower()+ model = llm_config.get("model_id", "gpt-4-turbo")+ temperature = llm_config.get("temperature", 0.7)+ max_tokens = llm_config.get("max_tokens", 2000)+ instructions = agent_config.get("instructions", "")++ # Build system prompt+ system_prompt = self._build_system_prompt(agent_config, instructions)++ try:+ if provider == "openai":+ return self._execute_openai(model, system_prompt, query, temperature, max_tokens)+ elif provider == "anthropic":+ return self._execute_anthropic(model, system_prompt, query, temperature, max_tokens)+ elif provider in ["google", "gemini"]:+ return self._execute_google(model, system_prompt, query, temperature, max_tokens)+ elif provider == "ollama":+ return self._execute_ollama(model, system_prompt, query, temperature, max_tokens)+ else:+ return {+ "success": False,+ "error": f"Unsupported provider: {provider}"+ }+ except Exception as e:+ return {+ "success": False,+ "error": f"LLM execution failed: {str(e)}"+ }++ def _build_system_prompt(self, agent_config: Dict, instructions: str) -> str:+ """Build comprehensive system prompt from agent config"""+ parts = []++ # Basic role+ role = agent_config.get("role", "")+ goal = agent_config.get("goal", "")+ if role:+ parts.append(f"Role: {role}")+ if goal:+ parts.append(f"Goal: {goal}")++ # Instructions+ if instructions:+ parts.append(f"\nInstructions:\n{instructions}")++ # Add scoring weights if available (for transparency)+ if "scoring_weights" in agent_config:+ parts.append("\nScoring Weights:")+ for key, value in agent_config["scoring_weights"].items():+ parts.append(f" - {key}: {value*100:.0f}%")++ # Add thresholds if available+ if "thresholds" in agent_config:+ parts.append("\nAnalysis Thresholds:")+ for key, value in agent_config["thresholds"].items():+ parts.append(f" - {key}: {value}")++ return "\n".join(parts)++ def _execute_openai(self, model: str, system_prompt: str, query: str,+ temperature: float, max_tokens: int) -> Dict:+ """Execute with OpenAI API"""+ try:+ from openai import OpenAI+ except ImportError:+ return {"success": False, "error": "openai package not installed"}++ api_key = self.api_keys.get("OPENAI_API_KEY")+ if not api_key:+ available_keys = [k for k in self.api_keys.keys() if k.endswith('_API_KEY')]+ suggestion = f" Available keys: {', '.join(available_keys)}" if available_keys else ""+ return {"success": False, "error": f"OPENAI_API_KEY not configured in Settings.{suggestion} Change agent's provider in JSON config or add OpenAI key in Settings."}++ try:+ client = OpenAI(api_key=api_key)++ # Use max_completion_tokens for newer models (GPT-4o, o1, etc)+ params = {+ "model": model,+ "messages": [+ {"role": "system", "content": system_prompt},+ {"role": "user", "content": query}+ ],+ "temperature": temperature+ }++ # OpenAI changed to max_completion_tokens for all newer models+ # Try max_completion_tokens first (works for gpt-4o, o1, o3, gpt-4-turbo-2024+)+ # Fall back to max_tokens for legacy models+ try:+ params["max_completion_tokens"] = max_tokens+ response = client.chat.completions.create(**params)+ except Exception as first_error:+ # If max_completion_tokens fails, try max_tokens+ if "max_completion_tokens" in str(first_error) or "unsupported_parameter" in str(first_error).lower():+ del params["max_completion_tokens"]+ params["max_tokens"] = max_tokens+ response = client.chat.completions.create(**params)+ else:+ raise first_error++ return {+ "success": True,+ "response": response.choices[0].message.content,+ "provider": "openai",+ "model": model,+ "tokens_used": response.usage.total_tokens if response.usage else 0,+ "finish_reason": response.choices[0].finish_reason+ }+ except Exception as e:+ return {+ "success": False,+ "error": f"OpenAI API error: {str(e)}"+ }++ def _execute_anthropic(self, model: str, system_prompt: str, query: str,+ temperature: float, max_tokens: int) -> Dict:+ """Execute with Anthropic Claude API"""+ try:+ from anthropic import Anthropic+ except ImportError:+ return {"success": False, "error": "anthropic package not installed"}++ api_key = self.api_keys.get("ANTHROPIC_API_KEY")+ if not api_key:+ return {"success": False, "error": "ANTHROPIC_API_KEY not configured in Settings"}++ try:+ client = Anthropic(api_key=api_key)++ response = client.messages.create(+ model=model,+ max_tokens=max_tokens,+ temperature=temperature,+ system=system_prompt,+ messages=[+ {"role": "user", "content": query}+ ]+ )++ return {+ "success": True,+ "response": response.content[0].text,+ "provider": "anthropic",+ "model": model,+ "tokens_used": response.usage.input_tokens + response.usage.output_tokens,+ "finish_reason": response.stop_reason+ }+ except Exception as e:+ return {+ "success": False,+ "error": f"Anthropic API error: {str(e)}"+ }++ def _execute_google(self, model: str, system_prompt: str, query: str,+ temperature: float, max_tokens: int) -> Dict:+ """Execute with Google Gemini API"""+ try:+ import google.generativeai as genai+ except ImportError:+ return {"success": False, "error": "google-generativeai package not installed"}++ api_key = self.api_keys.get("GOOGLE_API_KEY") or self.api_keys.get("GEMINI_API_KEY")+ if not api_key:+ return {"success": False, "error": "GOOGLE_API_KEY not configured in Settings"}++ try:+ genai.configure(api_key=api_key)++ model_instance = genai.GenerativeModel(model)++ # Combine system prompt and query for Gemini+ full_prompt = f"{system_prompt}\n\nUser Query: {query}"++ response = model_instance.generate_content(+ full_prompt,+ generation_config={+ "temperature": temperature,+ "max_output_tokens": max_tokens,+ }+ )++ return {+ "success": True,+ "response": response.text,+ "provider": "google",+ "model": model,+ "tokens_used": 0, # Gemini doesn't always return token counts+ "finish_reason": "complete"+ }+ except Exception as e:+ return {+ "success": False,+ "error": f"Google Gemini API error: {str(e)}"+ }++ def _execute_ollama(self, model: str, system_prompt: str, query: str,+ temperature: float, max_tokens: int) -> Dict:+ """Execute with local Ollama"""+ try:+ import requests+ except ImportError:+ return {"success": False, "error": "requests package not installed"}++ ollama_url = "http://localhost:11434/api/generate"++ try:+ payload = {+ "model": model,+ "prompt": f"{system_prompt}\n\nUser: {query}\nAssistant:",+ "stream": False,+ "options": {+ "temperature": temperature,+ "num_predict": max_tokens+ }+ }++ response = requests.post(ollama_url, json=payload, timeout=120)+ response.raise_for_status()++ result = response.json()++ return {+ "success": True,+ "response": result.get("response", ""),+ "provider": "ollama",+ "model": model,+ "tokens_used": result.get("eval_count", 0),+ "finish_reason": "complete"+ }+ except requests.exceptions.ConnectionError:+ return {+ "success": False,+ "error": "Ollama not running. Start Ollama server: ollama serve"+ }+ except Exception as e:+ return {+ "success": False,+ "error": f"Ollama error: {str(e)}"+ }diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tauri_bridge.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tauri_bridge.pyindex 08dd63c39..c62fc8cce 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tauri_bridge.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/finagent_core/tauri_bridge.py@@ -14,6 +14,7 @@ from pathlib import Pathsys.path.insert(0, str(Path(__file__).parent.parent))from finagent_core.base_agent import AgentRegistry, AgentConfig+from finagent_core.llm_executor import LLMExecutorclass TauriBridge:@@ -46,10 +47,16 @@ class TauriBridge:registry = AgentRegistry(config_path)agents = registry.list_agents()+ # Check if this is a team configuration+ team_name = registry.config_data.get("team_name", None)+ team_description = registry.config_data.get("team_description", None)+return {"success": True,"agents": [agent.to_dict() for agent in agents],- "count": len(agents)+ "count": len(agents),+ "team_name": team_name,+ "team_description": team_description}except Exception as e:return {@@ -145,11 +152,13 @@ class TauriBridge:}def execute_agent(self, parameters: Dict, inputs: Dict) -> Dict:- """Execute an agent (placeholder - actual execution requires LLM setup)"""+ """Execute an agent with real LLM execution"""try:agent_id = parameters.get("agent_id")category = parameters.get("category", "TraderInvestorsAgent")query = parameters.get("query", "")+ api_keys = inputs.get("api_keys", {})+ llm_override = inputs.get("llm_override", None)config_path = self.get_config_path(category)registry = AgentRegistry(config_path)@@ -161,19 +170,123 @@ class TauriBridge:"error": f"Agent not found: {agent_id}"}- # For now, return agent info (actual LLM execution would go here)- return {- "success": True,- "agent_id": agent_id,- "response": f"Agent '{agent.name}' received query: {query}\n\nNote: Full LLM execution requires API keys and Agno framework setup.",- "config": agent.to_dict()- }+ # Override LLM config with active provider from Settings+ agent_config = agent.to_dict()+ if llm_override:+ if "llm_config" not in agent_config:+ agent_config["llm_config"] = {}+ agent_config["llm_config"]["provider"] = llm_override.get("provider")+ agent_config["llm_config"]["model_id"] = llm_override.get("model")++ # Execute with real LLM+ executor = LLMExecutor(api_keys)+ result = executor.execute(agent_config, query)++ # Add agent metadata to result+ if result.get("success"):+ result["agent_id"] = agent_id+ result["agent_name"] = agent.name+ result["config"] = agent_config++ return resultexcept Exception as e:return {"success": False,"error": str(e)}+ def execute_team_collaboration(self, parameters: Dict, inputs: Dict) -> Dict:+ """Execute multi-agent collaboration discussion - SEQUENTIAL, one at a time"""+ try:+ category = parameters.get("category", "GeopoliticsAgents")+ query = parameters.get("query", "")+ api_keys = inputs.get("api_keys", {})+ llm_override = inputs.get("llm_override", None)+ agent_ids = parameters.get("agent_ids", None) # NEW: filter by specific agents++ config_path = self.get_config_path(category)+ registry = AgentRegistry(config_path)+ all_agents = registry.list_agents()++ # Filter agents if specific IDs provided (for book-specific discussion)+ if agent_ids:+ agents_list = [a for a in all_agents if a.id in agent_ids]+ else:+ agents_list = all_agents++ if not agents_list:+ return {"success": False, "error": "No agents found"}++ executor = LLMExecutor(api_keys)+ discussion = []++ # ROUND 1: Each agent analyzes query ONE BY ONE+ import sys+ sys.stderr.write(f"\n=== ROUND 1: Initial Analysis ({len(agents_list)} agents) ===\n")+ for idx, agent in enumerate(agents_list, 1):+ sys.stderr.write(f"Agent {idx}/{len(agents_list)}: {agent.name}\n")++ agent_config = agent.to_dict()+ if llm_override:+ if "llm_config" not in agent_config:+ agent_config["llm_config"] = {}+ agent_config["llm_config"]["provider"] = llm_override.get("provider")+ agent_config["llm_config"]["model_id"] = llm_override.get("model")++ result = executor.execute(agent_config, query)+ if result.get("success"):+ response = result.get("response", "")+ discussion.append({+ "agent": agent.name,+ "role": agent.role,+ "response": response,+ "round": 1+ })+ sys.stderr.write(f"[OK] {agent.name}: {response[:100]}...\n")+ else:+ sys.stderr.write(f"[FAIL] {agent.name}: Failed - {result.get('error', 'Unknown error')}\n")++ # ROUND 2: Agents respond to discussion ONE BY ONE+ sys.stderr.write(f"\n=== ROUND 2: Response to Discussion ===\n")+ context = f"Original Query: {query}\n\nDiscussion so far:\n"+ for d in discussion:+ context += f"\n{d['agent']}: {d['response'][:150]}...\n"+ context += "\n\nBased on the above discussion, provide your additional insights:"++ for idx, agent in enumerate(agents_list, 1):+ sys.stderr.write(f"Agent {idx}/{len(agents_list)}: {agent.name}\n")++ agent_config = agent.to_dict()+ if llm_override:+ agent_config["llm_config"]["provider"] = llm_override.get("provider")+ agent_config["llm_config"]["model_id"] = llm_override.get("model")++ result = executor.execute(agent_config, context)+ if result.get("success"):+ response = result.get("response", "")+ discussion.append({+ "agent": agent.name,+ "role": agent.role,+ "response": response,+ "round": 2+ })+ sys.stderr.write(f"[OK] {agent.name}: {response[:100]}...\n")+ else:+ sys.stderr.write(f"[FAIL] {agent.name}: Failed - {result.get('error', 'Unknown error')}\n")++ return {+ "success": True,+ "discussion": discussion,+ "total_agents": len(agents_list),+ "rounds": 2,+ "query": query+ }+ except Exception as e:+ import traceback+ sys.stderr.write(f"ERROR in execute_team_collaboration: {str(e)}\n")+ sys.stderr.write(traceback.format_exc())+ return {"success": False, "error": str(e)}+def execute(self, action: str, parameters: Dict, inputs: Dict) -> Dict:"""Execute an action"""actions = {@@ -182,11 +295,12 @@ class TauriBridge:"update_config": self.update_config,"get_providers": self.get_providers,"execute_agent": self.execute_agent,+ "execute_team_collaboration": self.execute_team_collaboration,}handler = actions.get(action)if handler:- if action == "execute_agent":+ if action in ["execute_agent", "execute_team_collaboration"]:return handler(parameters, inputs)else:return handler(parameters)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/agent_evolution.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/agent_evolution.pynew file mode 100644index 000000000..d18f61728--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/agent_evolution.py@@ -0,0 +1,350 @@+"""+Agent Evolution System+Self-learning agents that improve from trading history+"""++import json+import sys+from typing import Dict, Any, List, Optional+from datetime import datetime+from collections import Counter+++class AgentEvolution:+ """+ Manages agent self-evolution through performance analysis+ """++ def __init__(self):+ """Initialize evolution system"""+ self.evolution_triggers = {+ 'loss_streak': 3, # Evolve after 3 consecutive losses+ 'poor_win_rate': 0.40, # Evolve if win rate below 40%+ 'large_drawdown': 0.10, # Evolve if drawdown > 10%+ 'consistent_wins': 5, # Reinforce after 5 consecutive wins+ 'trades_milestone': 20 # Evolve every 20 trades+ }++ def should_evolve(self, agent_id: str, performance: Dict[str, Any]) -> tuple[bool, str]:+ """+ Check if agent should evolve based on performance++ Args:+ agent_id: Agent ID+ performance: Performance metrics++ Returns:+ (should_evolve, trigger_reason)+ """+ # Check loss streak+ if performance.get('consecutive_losses', 0) >= self.evolution_triggers['loss_streak']:+ return True, 'loss_streak'++ # Check poor win rate+ if performance.get('total_trades', 0) >= 10: # Need minimum trades+ if performance.get('win_rate', 100) < self.evolution_triggers['poor_win_rate'] * 100:+ return True, 'poor_win_rate'++ # Check large drawdown+ if performance.get('current_drawdown', 0) >= self.evolution_triggers['large_drawdown']:+ return True, 'large_drawdown'++ # Check trade milestones+ if performance.get('total_trades', 0) > 0 and performance.get('total_trades', 0) % self.evolution_triggers['trades_milestone'] == 0:+ return True, 'trades_milestone'++ return False, None++ def analyze_patterns(self, agent_id: str) -> Dict[str, Any]:+ """+ Analyze trading patterns from history++ Args:+ agent_id: Agent ID++ Returns:+ Pattern analysis+ """+ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()++ # Get trade history+ trades = db.get_agent_trades(agent_id, limit=100)++ if not trades:+ return {+ 'total_analyzed': 0,+ 'patterns': {}+ }++ # Separate winners and losers+ winners = [t for t in trades if t['pnl'] > 0]+ losers = [t for t in trades if t['pnl'] < 0]++ analysis = {+ 'total_analyzed': len(trades),+ 'winners_count': len(winners),+ 'losers_count': len(losers),+ 'patterns': {}+ }++ # Pattern 1: Winning vs Losing Symbols+ winning_symbols = Counter([t['symbol'] for t in winners])+ losing_symbols = Counter([t['symbol'] for t in losers])++ analysis['patterns']['best_symbols'] = [sym for sym, _ in winning_symbols.most_common(3)]+ analysis['patterns']['worst_symbols'] = [sym for sym, _ in losing_symbols.most_common(3)]++ # Pattern 2: Winning vs Losing Sides+ winning_sides = Counter([t['side'] for t in winners])+ losing_sides = Counter([t['side'] for t in losers])++ analysis['patterns']['best_side'] = winning_sides.most_common(1)[0][0] if winning_sides else 'buy'+ analysis['patterns']['worst_side'] = losing_sides.most_common(1)[0][0] if losing_sides else None++ # Pattern 3: Trade timing (hour of day if available)+ # Pattern 4: Position sizing patterns+ avg_winning_size = sum(t['quantity'] * t['entry_price'] for t in winners) / len(winners) if winners else 0+ avg_losing_size = sum(t['quantity'] * t['entry_price'] for t in losers) / len(losers) if losers else 0++ analysis['patterns']['avg_winning_size'] = avg_winning_size+ analysis['patterns']['avg_losing_size'] = avg_losing_size++ if avg_winning_size < avg_losing_size:+ analysis['patterns']['sizing_issue'] = 'winning_trades_too_small'+ elif avg_losing_size > avg_winning_size * 1.5:+ analysis['patterns']['sizing_issue'] = 'losing_trades_too_large'+ else:+ analysis['patterns']['sizing_issue'] = None++ # Pattern 5: Stop loss hit rate+ trades_with_sl = [t for t in trades if t['stop_loss'] is not None]+ if trades_with_sl:+ sl_hit_count = sum(1 for t in losers if t['stop_loss'] and abs(t['exit_price'] - t['stop_loss']) / t['stop_loss'] < 0.01)+ analysis['patterns']['stop_loss_hit_rate'] = sl_hit_count / len(losers) if losers else 0+ else:+ analysis['patterns']['stop_loss_hit_rate'] = 0++ # Pattern 6: Take profit hit rate+ trades_with_tp = [t for t in trades if t['take_profit'] is not None]+ if trades_with_tp:+ tp_hit_count = sum(1 for t in winners if t['take_profit'] and abs(t['exit_price'] - t['take_profit']) / t['take_profit'] < 0.01)+ analysis['patterns']['take_profit_hit_rate'] = tp_hit_count / len(winners) if winners else 0+ else:+ analysis['patterns']['take_profit_hit_rate'] = 0++ return analysis++ def generate_new_instructions(+ self,+ agent_id: str,+ current_instructions: List[str],+ patterns: Dict[str, Any],+ trigger: str+ ) -> List[str]:+ """+ Generate improved instructions based on patterns++ Args:+ agent_id: Agent ID+ current_instructions: Current agent instructions+ patterns: Pattern analysis+ trigger: Evolution trigger++ Returns:+ New instructions+ """+ new_instructions = current_instructions.copy()++ # Add learning-based instructions+ learning_instructions = []++ # From symbol patterns+ if patterns.get('best_symbols'):+ learning_instructions.append(+ f"LEARNED: You have better win rates with {', '.join(patterns['best_symbols'][:2])}. Favor these symbols when possible."+ )++ if patterns.get('worst_symbols'):+ learning_instructions.append(+ f"LEARNED: You have poor performance with {', '.join(patterns['worst_symbols'][:2])}. Be more cautious or avoid these symbols."+ )++ # From side patterns+ if patterns.get('best_side') and patterns.get('worst_side'):+ if patterns['best_side'] != patterns['worst_side']:+ learning_instructions.append(+ f"LEARNED: Your {patterns['best_side'].upper()} trades outperform {patterns['worst_side'].upper()} trades. Focus on {patterns['best_side'].upper()} setups."+ )++ # From sizing patterns+ sizing_issue = patterns.get('sizing_issue')+ if sizing_issue == 'winning_trades_too_small':+ learning_instructions.append(+ "LEARNED: Your winning trades are smaller than losing trades. Increase position size on high-confidence setups."+ )+ elif sizing_issue == 'losing_trades_too_large':+ learning_instructions.append(+ "LEARNED: Your losing trades are too large. Reduce position size to manage risk better."+ )++ # From stop loss patterns+ sl_hit_rate = patterns.get('stop_loss_hit_rate', 0)+ if sl_hit_rate > 0.7:+ learning_instructions.append(+ "LEARNED: Your stop losses are being hit frequently (70%+). Consider wider stops or better entry timing."+ )+ elif sl_hit_rate < 0.3:+ learning_instructions.append(+ "LEARNED: Your stop losses are rarely hit. Your risk management is working well - maintain this approach."+ )++ # From take profit patterns+ tp_hit_rate = patterns.get('take_profit_hit_rate', 0)+ if tp_hit_rate > 0.7:+ learning_instructions.append(+ "LEARNED: Your take profit targets are being hit consistently. Consider setting more ambitious targets."+ )+ elif tp_hit_rate < 0.3:+ learning_instructions.append(+ "LEARNED: Your take profit targets are rarely hit. Consider more conservative targets or trailing stops."+ )++ # Trigger-specific instructions+ if trigger == 'loss_streak':+ learning_instructions.append(+ "CAUTION: You're currently in a losing streak. Reduce position sizes by 50% until you have 2 consecutive wins."+ )+ elif trigger == 'poor_win_rate':+ learning_instructions.append(+ "STRATEGY SHIFT: Your win rate is below 40%. Focus on HIGH PROBABILITY setups only. Skip marginal trades."+ )+ elif trigger == 'large_drawdown':+ learning_instructions.append(+ "RISK ALERT: Drawdown is over 10%. STOP TRADING until you review your strategy. Reduce position sizes when resuming."+ )++ # Prepend learning instructions+ new_instructions = learning_instructions + new_instructions++ return new_instructions++ def evolve_agent(+ self,+ agent_id: str,+ model: str,+ current_instructions: List[str],+ trigger: str,+ notes: Optional[str] = None+ ) -> Dict[str, Any]:+ """+ Evolve an agent based on performance++ Args:+ agent_id: Agent ID+ model: Model name+ current_instructions: Current instructions+ trigger: Evolution trigger+ notes: Optional notes++ Returns:+ Evolution result+ """+ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()++ try:+ # Get current performance+ performance = db.get_agent_performance(agent_id)+ if not performance:+ return {'success': False, 'error': 'Agent performance not found'}++ # Analyze patterns+ patterns = self.analyze_patterns(agent_id)++ # Generate new instructions+ new_instructions = self.generate_new_instructions(+ agent_id,+ current_instructions,+ patterns['patterns'],+ trigger+ )++ # Record evolution+ evolution_data = {+ 'agent_id': agent_id,+ 'model': model,+ 'evolution_trigger': trigger,+ 'old_instructions': json.dumps(current_instructions),+ 'new_instructions': json.dumps(new_instructions),+ 'metrics_before': json.dumps({+ 'total_pnl': performance['total_pnl'],+ 'win_rate': performance['win_rate'],+ 'total_trades': performance['total_trades'],+ 'sharpe_ratio': performance['sharpe_ratio']+ }),+ 'metrics_after': json.dumps({}), # Will be updated later+ 'timestamp': int(datetime.now().timestamp()),+ 'notes': notes or json.dumps(patterns)+ }++ db.log_evolution(evolution_data)++ return {+ 'success': True,+ 'agent_id': agent_id,+ 'trigger': trigger,+ 'old_instructions': current_instructions,+ 'new_instructions': new_instructions,+ 'patterns': patterns,+ 'metrics_before': {+ 'total_pnl': performance['total_pnl'],+ 'win_rate': performance['win_rate'],+ 'total_trades': performance['total_trades']+ }+ }++ except Exception as e:+ print(f"[Evolution] Error: {str(e)}", file=sys.stderr)+ import traceback+ traceback.print_exc(file=sys.stderr)++ return {+ 'success': False,+ 'error': f"Evolution failed: {str(e)}"+ }++ def get_evolution_summary(self, agent_id: str) -> Dict[str, Any]:+ """+ Get evolution summary for an agent++ Args:+ agent_id: Agent ID++ Returns:+ Evolution summary+ """+ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()++ history = db.get_evolution_history(agent_id, limit=10)+ performance = db.get_agent_performance(agent_id)++ return {+ 'agent_id': agent_id,+ 'total_evolutions': len(history),+ 'evolution_history': history,+ 'current_performance': performance,+ 'last_evolution': history[0] if history else None+ }+++# Global instance+_agent_evolution = None++def get_agent_evolution() -> AgentEvolution:+ """Get singleton agent evolution system"""+ global _agent_evolution+ if _agent_evolution is None:+ _agent_evolution = AgentEvolution()+ return _agent_evolutiondiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/base_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/base_agent.pyindex 24f9f74b1..35cf3f8df 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/base_agent.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/base_agent.py@@ -6,6 +6,7 @@ All specialized trading agents inherit from this base class."""import os+import sysimport jsonfrom typing import List, Optional, Dict, Any, Unionfrom datetime import datetime@@ -149,8 +150,13 @@ class BaseAgent:from agno.models.anthropic import Claudereturn Claude(**model_config)elif provider == "google":- from agno.models.google import Gemini- return Gemini(**model_config)+ # Use OpenAI-compatible API for Google Gemini+ from agno.models.openai import OpenAIChat+ return OpenAIChat(+ id=model_name,+ api_key=api_key,+ base_url="https://generativelanguage.googleapis.com/v1beta/openai/"+ )elif provider == "groq":from agno.models.groq import Groqreturn Groq(**model_config)@@ -199,13 +205,19 @@ class BaseAgent:def _get_market_data_tools(self) -> List[Any]:"""Get market data tools"""- # Placeholder - will be implemented in tools/market_data.py- return []+ try:+ from tools.market_data import get_market_data_tools+ return get_market_data_tools()+ except ImportError:+ return []def _get_technical_analysis_tools(self) -> List[Any]:"""Get technical analysis tools"""- # Placeholder - will be implemented in tools/technical_indicators.py- return []+ try:+ from tools.technical_indicators import get_technical_analysis_tools+ return get_technical_analysis_tools()+ except ImportError:+ return []def _get_order_execution_tools(self) -> List[Any]:"""Get order execution tools"""@@ -252,8 +264,6 @@ class BaseAgent:"instructions": self.config.instructions,"tools": self.tools if self.tools else None,"knowledge": self.knowledge,- "memory": self.memory,- "show_tool_calls": self.config.show_tool_calls,"markdown": self.config.markdown,}@@ -285,6 +295,13 @@ class BaseAgent:Returns:ModelResponse object or streaming response"""+ # Log what's being sent to the model+ print(f"\n{'='*80}", file=sys.stderr)+ print(f"[Agent: {self.config.name}] Running with model: {self.config.model_provider}:{self.config.model_name}", file=sys.stderr)+ print(f"Prompt length: {len(prompt)} chars", file=sys.stderr)+ print(f"Prompt preview: {prompt[:500]}...", file=sys.stderr)+ print(f"{'='*80}\n", file=sys.stderr)+# Track in sessionif session_id:if session_id not in self.sessions:@@ -295,17 +312,8 @@ class BaseAgent:"type": "user"})- # Run agent- run_params = {- "message": prompt,- "stream": stream or self.config.stream,- **kwargs- }-- if session_id:- run_params["session_id"] = session_id-- response = self.agent.run(**run_params)+ # Run agent (Agno uses 'input' parameter)+ response = self.agent.run(prompt, stream=stream or self.config.stream, **kwargs)# Track response in sessionif session_id and not stream:diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/debate_orchestrator.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/debate_orchestrator.pynew file mode 100644index 000000000..f999e6543--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/debate_orchestrator.py@@ -0,0 +1,424 @@+"""+Debate Orchestrator+Manages Bull/Bear/Analyst debate system for trading decisions+"""++import sys+import json+from typing import Dict, Any, List, Optional+from datetime import datetime+import time++try:+ from agno.agent import Agent+ from agno.models.response import ModelResponse+ AGNO_AVAILABLE = True+except ImportError:+ AGNO_AVAILABLE = False+ Agent = None+ ModelResponse = None+++class DebateOrchestrator:+ """+ Orchestrates multi-agent debates for trading decisions+ Bull/Bear/Analyst format inspired by Alpha Arena+ """++ def __init__(self):+ """Initialize debate orchestrator"""+ if not AGNO_AVAILABLE:+ raise ImportError("Agno framework not available")++ def create_debate_agents(+ self,+ bull_model: str,+ bear_model: str,+ analyst_model: str,+ api_keys: Dict[str, str]+ ) -> Dict[str, Agent]:+ """+ Create Bull, Bear, and Analyst agents++ Args:+ bull_model: Model for bull agent (e.g., "openai:gpt-4o")+ bear_model: Model for bear agent+ analyst_model: Model for analyst agent+ api_keys: API keys for providers++ Returns:+ Dictionary of agents+ """+ # Set API keys+ import os+ for key, value in api_keys.items():+ os.environ[key] = value++ # Parse model strings+ bull_provider, bull_model_name = self._parse_model_string(bull_model)+ bear_provider, bear_model_name = self._parse_model_string(bear_model)+ analyst_provider, analyst_model_name = self._parse_model_string(analyst_model)++ # Initialize models+ bull_llm = self._get_model(bull_provider, bull_model_name, api_keys)+ bear_llm = self._get_model(bear_provider, bear_model_name, api_keys)+ analyst_llm = self._get_model(analyst_provider, analyst_model_name, api_keys)++ # Create Bull Agent (Optimistic)+ bull_agent = Agent(+ name="Bull Agent",+ role="Bullish Market Analyst",+ model=bull_llm,+ description="Analyzes markets from a bullish perspective, identifying opportunities for long positions",+ instructions=[+ "You are a bullish trading analyst. Your role is to identify REASONS TO BUY.",+ "Analyze market data, technical indicators, and sentiment to build a BULLISH case.",+ "Focus on: upward momentum, support levels, positive catalysts, bullish patterns.",+ "Be persuasive but use data and reasoning to support your arguments.",+ "Structure your argument: 1) Technical Analysis 2) Fundamental Catalysts 3) Risk Factors 4) Entry Strategy",+ "End with a clear BUY recommendation and target price if the case is strong."+ ],+ markdown=True+ )++ # Create Bear Agent (Pessimistic)+ bear_agent = Agent(+ name="Bear Agent",+ role="Bearish Market Analyst",+ model=bear_llm,+ description="Analyzes markets from a bearish perspective, identifying risks for short positions or avoiding longs",+ instructions=[+ "You are a bearish trading analyst. Your role is to identify REASONS TO SELL or AVOID.",+ "Analyze market data, technical indicators, and sentiment to build a BEARISH case.",+ "Focus on: downward momentum, resistance levels, negative catalysts, bearish patterns.",+ "Be persuasive but use data and reasoning to support your arguments.",+ "Structure your argument: 1) Technical Weaknesses 2) Fundamental Risks 3) Market Conditions 4) Exit/Short Strategy",+ "End with a clear SELL/AVOID recommendation and target price if the case is strong."+ ],+ markdown=True+ )++ # Create Analyst Agent (Neutral Decision Maker)+ analyst_agent = Agent(+ name="Analyst Agent",+ role="Chief Trading Analyst",+ model=analyst_llm,+ description="Synthesizes bull and bear arguments to make final trading decision",+ instructions=[+ "You are the CHIEF ANALYST. You listen to both BULL and BEAR arguments and make the FINAL DECISION.",+ "Be OBJECTIVE and DATA-DRIVEN. Do not favor either side - evaluate based on strength of evidence.",+ "Your decision process:",+ " 1) Summarize bull's strongest points",+ " 2) Summarize bear's strongest points",+ " 3) Identify which side has stronger evidence",+ " 4) Consider risk/reward ratio",+ " 5) Make FINAL CALL: BUY, SELL, or HOLD",+ "Provide: Action (BUY/SELL/HOLD), Entry Price, Stop Loss, Take Profit, Position Size %, Confidence (0-100%)",+ "Be decisive - the market waits for no one."+ ],+ markdown=True+ )++ return {+ 'bull': bull_agent,+ 'bear': bear_agent,+ 'analyst': analyst_agent+ }++ def run_debate(+ self,+ symbol: str,+ market_data: Dict[str, Any],+ bull_model: str,+ bear_model: str,+ analyst_model: str,+ api_keys: Dict[str, str]+ ) -> Dict[str, Any]:+ """+ Run a full debate session++ Args:+ symbol: Trading symbol+ market_data: Market data context+ bull_model: Bull agent model+ bear_model: Bear agent model+ analyst_model: Analyst agent model+ api_keys: API keys++ Returns:+ Debate result with final decision+ """+ start_time = time.time()++ try:+ # Create agents+ agents = self.create_debate_agents(bull_model, bear_model, analyst_model, api_keys)++ # Prepare market context+ context = self._format_market_context(symbol, market_data)++ # Step 1: Bull makes case+ print(f"[Debate] Bull agent analyzing {symbol}...", file=sys.stderr)+ bull_prompt = f"""+Analyze {symbol} and make a BULLISH case for why traders should BUY.++Market Context:+{context}++Provide your analysis with supporting data and reasoning.+"""+ bull_response = agents['bull'].run(bull_prompt, stream=False)+ bull_argument = self._extract_response_content(bull_response)++ print(f"[Debate] Bull argument: {len(bull_argument)} chars", file=sys.stderr)++ # Step 2: Bear makes case+ print(f"[Debate] Bear agent analyzing {symbol}...", file=sys.stderr)+ bear_prompt = f"""+Analyze {symbol} and make a BEARISH case for why traders should SELL or AVOID.++Market Context:+{context}++Provide your analysis with supporting data and reasoning.+"""+ bear_response = agents['bear'].run(bear_prompt, stream=False)+ bear_argument = self._extract_response_content(bear_response)++ print(f"[Debate] Bear argument: {len(bear_argument)} chars", file=sys.stderr)++ # Step 3: Analyst makes final decision+ print(f"[Debate] Analyst making final decision...", file=sys.stderr)+ analyst_prompt = f"""+You have heard both sides of the debate for {symbol}.++**BULL ARGUMENT:**+{bull_argument}++**BEAR ARGUMENT:**+{bear_argument}++**MARKET DATA:**+{context}++As the Chief Analyst, make your FINAL TRADING DECISION.++Format your response as:+DECISION: [BUY/SELL/HOLD]+CONFIDENCE: [0-100]%+ENTRY PRICE: $[price]+STOP LOSS: $[price]+TAKE PROFIT: $[price]+POSITION SIZE: [0-100]%+REASONING: [Brief explanation of why you made this decision]+"""+ analyst_response = agents['analyst'].run(analyst_prompt, stream=False)+ analyst_decision = self._extract_response_content(analyst_response)++ print(f"[Debate] Analyst decision: {len(analyst_decision)} chars", file=sys.stderr)++ # Parse analyst decision+ final_decision = self._parse_analyst_decision(analyst_decision)++ # Calculate execution time+ execution_time_ms = int((time.time() - start_time) * 1000)++ # Record debate in database+ debate_data = {+ 'id': f"debate_{symbol}_{int(datetime.now().timestamp())}",+ 'symbol': symbol,+ 'bull_model': bull_model,+ 'bear_model': bear_model,+ 'analyst_model': analyst_model,+ 'bull_argument': bull_argument,+ 'bear_argument': bear_argument,+ 'analyst_decision': analyst_decision,+ 'final_action': final_decision.get('action', 'HOLD'),+ 'confidence': final_decision.get('confidence', 50),+ 'timestamp': int(datetime.now().timestamp()),+ 'execution_time_ms': execution_time_ms+ }++ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()+ debate_id = db.record_debate(debate_data)++ return {+ 'success': True,+ 'debate_id': debate_id,+ 'symbol': symbol,+ 'bull_argument': bull_argument,+ 'bear_argument': bear_argument,+ 'analyst_decision': analyst_decision,+ 'final_action': final_decision.get('action'),+ 'confidence': final_decision.get('confidence'),+ 'entry_price': final_decision.get('entry_price'),+ 'stop_loss': final_decision.get('stop_loss'),+ 'take_profit': final_decision.get('take_profit'),+ 'position_size': final_decision.get('position_size'),+ 'reasoning': final_decision.get('reasoning'),+ 'execution_time_ms': execution_time_ms+ }++ except Exception as e:+ print(f"[Debate] Error: {str(e)}", file=sys.stderr)+ import traceback+ traceback.print_exc(file=sys.stderr)++ return {+ 'success': False,+ 'error': f"Debate failed: {str(e)}"+ }++ def _parse_model_string(self, model_string: str) -> tuple:+ """Parse model string like 'openai:gpt-4o' into provider and model name"""+ if ':' in model_string:+ provider, model = model_string.split(':', 1)+ else:+ provider = 'openai'+ model = model_string++ # Normalize provider+ provider = provider.lower()+ if provider == 'gemini':+ provider = 'google'++ return provider, model++ def _get_model(self, provider: str, model_name: str, api_keys: Dict[str, str]):+ """Get LLM model instance"""+ from agno.models.openai import OpenAIChat++ api_key_map = {+ 'openai': 'OPENAI_API_KEY',+ 'google': 'GOOGLE_API_KEY',+ 'anthropic': 'ANTHROPIC_API_KEY',+ 'groq': 'GROQ_API_KEY',+ 'deepseek': 'DEEPSEEK_API_KEY',+ 'xai': 'XAI_API_KEY'+ }++ key_name = api_key_map.get(provider, f"{provider.upper()}_API_KEY")+ api_key = api_keys.get(key_name, api_keys.get(f"GEMINI_API_KEY" if provider == "google" else ""))++ if provider == 'openai':+ from agno.models.openai import OpenAIChat+ return OpenAIChat(id=model_name, api_key=api_key)+ elif provider == 'anthropic':+ from agno.models.anthropic import Claude+ return Claude(id=model_name, api_key=api_key)+ elif provider == 'google':+ return OpenAIChat(+ id=model_name,+ api_key=api_key,+ base_url="https://generativelanguage.googleapis.com/v1beta/openai/"+ )+ elif provider == 'groq':+ from agno.models.groq import Groq+ return Groq(id=model_name, api_key=api_key)+ elif provider == 'deepseek':+ return OpenAIChat(+ id=model_name,+ api_key=api_key,+ base_url="https://api.deepseek.com"+ )+ elif provider == 'xai':+ return OpenAIChat(+ id=model_name,+ api_key=api_key,+ base_url="https://api.x.ai/v1"+ )+ else:+ return OpenAIChat(id=model_name, api_key=api_key)++ def _format_market_context(self, symbol: str, market_data: Dict[str, Any]) -> str:+ """Format market data into readable context"""+ context_parts = [f"Symbol: {symbol}"]++ if 'price' in market_data:+ context_parts.append(f"Current Price: ${market_data['price']:.2f}")++ if 'change_24h' in market_data:+ context_parts.append(f"24h Change: {market_data['change_24h']:+.2f}%")++ if 'volume_24h' in market_data:+ context_parts.append(f"24h Volume: ${market_data['volume_24h']:,.0f}")++ if 'indicators' in market_data:+ context_parts.append("\nTechnical Indicators:")+ for key, value in market_data['indicators'].items():+ context_parts.append(f" - {key}: {value}")++ return "\n".join(context_parts)++ def _extract_response_content(self, response: ModelResponse) -> str:+ """Extract content from model response"""+ if hasattr(response, 'content'):+ return response.content+ elif hasattr(response, 'message'):+ return response.message+ else:+ return str(response)++ def _parse_analyst_decision(self, decision_text: str) -> Dict[str, Any]:+ """Parse analyst decision text into structured format"""+ import re++ result = {+ 'action': 'HOLD',+ 'confidence': 50,+ 'entry_price': None,+ 'stop_loss': None,+ 'take_profit': None,+ 'position_size': 10,+ 'reasoning': ''+ }++ # Extract DECISION+ decision_match = re.search(r'DECISION:\s*(\w+)', decision_text, re.IGNORECASE)+ if decision_match:+ result['action'] = decision_match.group(1).upper()++ # Extract CONFIDENCE+ confidence_match = re.search(r'CONFIDENCE:\s*(\d+)', decision_text, re.IGNORECASE)+ if confidence_match:+ result['confidence'] = int(confidence_match.group(1))++ # Extract prices+ entry_match = re.search(r'ENTRY PRICE:\s*\$?([0-9,.]+)', decision_text, re.IGNORECASE)+ if entry_match:+ result['entry_price'] = float(entry_match.group(1).replace(',', ''))++ sl_match = re.search(r'STOP LOSS:\s*\$?([0-9,.]+)', decision_text, re.IGNORECASE)+ if sl_match:+ result['stop_loss'] = float(sl_match.group(1).replace(',', ''))++ tp_match = re.search(r'TAKE PROFIT:\s*\$?([0-9,.]+)', decision_text, re.IGNORECASE)+ if tp_match:+ result['take_profit'] = float(tp_match.group(1).replace(',', ''))++ # Extract position size+ pos_match = re.search(r'POSITION SIZE:\s*(\d+)', decision_text, re.IGNORECASE)+ if pos_match:+ result['position_size'] = int(pos_match.group(1))++ # Extract reasoning+ reasoning_match = re.search(r'REASONING:\s*(.+?)(?:\n\n|\Z)', decision_text, re.IGNORECASE | re.DOTALL)+ if reasoning_match:+ result['reasoning'] = reasoning_match.group(1).strip()+ else:+ # Use full text as reasoning if no specific section found+ result['reasoning'] = decision_text[:500]++ return result+++# Global instance+_debate_orchestrator = None++def get_debate_orchestrator() -> DebateOrchestrator:+ """Get singleton debate orchestrator"""+ global _debate_orchestrator+ if _debate_orchestrator is None:+ _debate_orchestrator = DebateOrchestrator()+ return _debate_orchestratordiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/trade_executor.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/trade_executor.pynew file mode 100644index 000000000..2b375e2d9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/core/trade_executor.py@@ -0,0 +1,284 @@+"""+Trade Executor+Executes trades based on agent signals with risk management+"""++import json+import sys+from typing import Dict, Any, Optional+from datetime import datetime+++class TradeExecutor:+ """+ Executes trades with risk validation and position management+ """++ def __init__(self, risk_config: Optional[Dict] = None):+ """+ Initialize trade executor++ Args:+ risk_config: Risk management configuration+ """+ self.risk_config = risk_config or {+ 'max_position_size_pct': 0.10, # 10% of portfolio+ 'max_leverage': 2.0,+ 'max_daily_loss_pct': 0.05, # 5% max daily loss+ 'min_risk_reward_ratio': 1.5,+ 'max_open_positions': 5,+ 'enable_stop_loss': True,+ 'enable_take_profit': True+ }++ def validate_trade_signal(+ self,+ signal: Dict[str, Any],+ portfolio_data: Dict[str, Any]+ ) -> Dict[str, Any]:+ """+ Validate trade signal against risk management rules++ Args:+ signal: Trade signal from agent+ portfolio_data: Current portfolio state++ Returns:+ Validation result with approved status and adjusted parameters+ """+ validation = {+ 'approved': True,+ 'reasons': [],+ 'warnings': [],+ 'adjusted_signal': signal.copy()+ }++ portfolio_value = portfolio_data.get('total_value', 10000.0)+ daily_pnl = portfolio_data.get('daily_pnl', 0)+ open_positions = len(portfolio_data.get('positions', []))++ # Check 1: Daily loss limit+ if daily_pnl < 0:+ daily_loss_pct = abs(daily_pnl / portfolio_value)+ if daily_loss_pct >= self.risk_config['max_daily_loss_pct']:+ validation['approved'] = False+ validation['reasons'].append(+ f"Daily loss limit reached ({daily_loss_pct*100:.1f}% >= {self.risk_config['max_daily_loss_pct']*100}%)"+ )+ return validation++ # Check 2: Max open positions+ if open_positions >= self.risk_config['max_open_positions']:+ validation['approved'] = False+ validation['reasons'].append(+ f"Maximum open positions reached ({open_positions}/{self.risk_config['max_open_positions']})"+ )+ return validation++ # Check 3: Position size limit+ intended_value = signal.get('quantity', 0) * signal.get('entry_price', 0)+ position_size_pct = intended_value / portfolio_value++ max_allowed_pct = self.risk_config['max_position_size_pct']++ if position_size_pct > max_allowed_pct:+ # Adjust quantity to fit within limits+ adjusted_quantity = (portfolio_value * max_allowed_pct) / signal.get('entry_price', 1)+ validation['adjusted_signal']['quantity'] = adjusted_quantity+ validation['warnings'].append(+ f"Position size reduced from {position_size_pct*100:.1f}% to {max_allowed_pct*100}%"+ )++ # Check 4: Risk/Reward ratio (if stop loss and take profit provided)+ if signal.get('stop_loss') and signal.get('take_profit'):+ entry_price = signal.get('entry_price', 0)+ stop_loss = signal['stop_loss']+ take_profit = signal['take_profit']+ side = signal.get('side', 'buy')++ if side == 'buy':+ risk = abs(entry_price - stop_loss)+ reward = abs(take_profit - entry_price)+ else: # sell/short+ risk = abs(stop_loss - entry_price)+ reward = abs(entry_price - take_profit)++ rr_ratio = reward / risk if risk > 0 else 0++ if rr_ratio < self.risk_config['min_risk_reward_ratio']:+ validation['approved'] = False+ validation['reasons'].append(+ f"Risk/Reward ratio too low ({rr_ratio:.2f} < {self.risk_config['min_risk_reward_ratio']})"+ )+ return validation++ # Check 5: Mandatory stop loss+ if self.risk_config['enable_stop_loss'] and not signal.get('stop_loss'):+ # Auto-calculate stop loss (2% from entry)+ entry_price = signal.get('entry_price', 0)+ side = signal.get('side', 'buy')++ if side == 'buy':+ auto_stop_loss = entry_price * 0.98 # 2% below+ else:+ auto_stop_loss = entry_price * 1.02 # 2% above++ validation['adjusted_signal']['stop_loss'] = auto_stop_loss+ validation['warnings'].append(f"Auto stop-loss added at {auto_stop_loss:.2f}")++ # Check 6: Mandatory take profit+ if self.risk_config['enable_take_profit'] and not signal.get('take_profit'):+ # Auto-calculate take profit (4% from entry for 2:1 R:R)+ entry_price = signal.get('entry_price', 0)+ side = signal.get('side', 'buy')++ if side == 'buy':+ auto_take_profit = entry_price * 1.04 # 4% above+ else:+ auto_take_profit = entry_price * 0.96 # 4% below++ validation['adjusted_signal']['take_profit'] = auto_take_profit+ validation['warnings'].append(f"Auto take-profit added at {auto_take_profit:.2f}")++ return validation++ def execute_trade(+ self,+ signal: Dict[str, Any],+ portfolio_data: Dict[str, Any],+ agent_id: str,+ model: str,+ paper_trading: bool = True+ ) -> Dict[str, Any]:+ """+ Execute trade with risk validation++ Args:+ signal: Trade signal+ portfolio_data: Current portfolio state+ agent_id: Agent identifier+ model: Model name+ paper_trading: Whether this is paper trading++ Returns:+ Execution result+ """+ start_time = datetime.now()++ # Validate signal+ validation = self.validate_trade_signal(signal, portfolio_data)++ if not validation['approved']:+ return {+ 'success': False,+ 'error': 'Trade rejected by risk management',+ 'reasons': validation['reasons'],+ 'warnings': validation['warnings']+ }++ # Use adjusted signal+ adjusted_signal = validation['adjusted_signal']++ # Prepare trade data+ trade_data = {+ 'agent_id': agent_id,+ 'model': model,+ 'symbol': adjusted_signal['symbol'],+ 'side': adjusted_signal.get('side', 'buy'),+ 'order_type': adjusted_signal.get('order_type', 'market'),+ 'quantity': adjusted_signal.get('quantity', 0),+ 'entry_price': adjusted_signal.get('entry_price', 0),+ 'stop_loss': adjusted_signal.get('stop_loss'),+ 'take_profit': adjusted_signal.get('take_profit'),+ 'reasoning': adjusted_signal.get('reasoning', ''),+ 'metadata': {+ 'strategy': adjusted_signal.get('strategy'),+ 'confidence': adjusted_signal.get('confidence'),+ 'indicators': adjusted_signal.get('indicators', {}),+ 'original_signal': signal+ },+ 'is_paper_trade': paper_trading,+ 'entry_timestamp': int(datetime.now().timestamp()),+ 'execution_time_ms': 0+ }++ # Record in database+ try:+ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()+ trade_id = db.record_trade(trade_data)++ # Log decision+ db.log_decision({+ 'agent_id': agent_id,+ 'model': model,+ 'decision_type': 'trade',+ 'symbol': adjusted_signal['symbol'],+ 'decision': f"{adjusted_signal['side'].upper()} {adjusted_signal['quantity']:.4f} @ {adjusted_signal['entry_price']:.2f}",+ 'reasoning': adjusted_signal.get('reasoning'),+ 'confidence': adjusted_signal.get('confidence'),+ 'timestamp': int(datetime.now().timestamp())+ })++ execution_time_ms = int((datetime.now() - start_time).total_seconds() * 1000)++ return {+ 'success': True,+ 'trade_id': trade_id,+ 'trade_data': trade_data,+ 'warnings': validation['warnings'],+ 'execution_time_ms': execution_time_ms+ }++ except Exception as e:+ return {+ 'success': False,+ 'error': f"Trade execution failed: {str(e)}"+ }++ def close_position(+ self,+ trade_id: int,+ exit_price: float,+ reason: str = 'manual'+ ) -> Dict[str, Any]:+ """+ Close an open position++ Args:+ trade_id: Trade ID to close+ exit_price: Exit price+ reason: Reason for closing++ Returns:+ Close result+ """+ try:+ from agno_trading.db.database_manager import get_db_manager+ db = get_db_manager()++ db.close_trade(trade_id, exit_price)++ return {+ 'success': True,+ 'trade_id': trade_id,+ 'exit_price': exit_price,+ 'reason': reason+ }++ except Exception as e:+ return {+ 'success': False,+ 'error': f"Failed to close position: {str(e)}"+ }+++# Global instance+_trade_executor = None++def get_trade_executor() -> TradeExecutor:+ """Get singleton trade executor"""+ global _trade_executor+ if _trade_executor is None:+ _trade_executor = TradeExecutor()+ return _trade_executordiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/database_manager.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/database_manager.pynew file mode 100644index 000000000..07db98893--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/database_manager.py@@ -0,0 +1,480 @@+"""+Database Manager for Agno Trading System+Handles all database operations for agent trades, performance, decisions, and evolution+"""++import sqlite3+import json+import os+from typing import Dict, List, Any, Optional, Tuple+from datetime import datetime, timedelta+import sys++class DatabaseManager:+ def __init__(self, db_path: Optional[str] = None):+ """Initialize database manager"""+ if db_path is None:+ # Default to agno_trading.db in same directory+ db_path = os.path.join(os.path.dirname(__file__), 'agno_trading.db')++ self.db_path = db_path+ self.initialize_database()++ def get_connection(self) -> sqlite3.Connection:+ """Get database connection"""+ conn = sqlite3.connect(self.db_path)+ conn.row_factory = sqlite3.Row+ return conn++ def initialize_database(self):+ """Create tables if they don't exist"""+ schema_path = os.path.join(os.path.dirname(__file__), 'schema.sql')++ if os.path.exists(schema_path):+ with open(schema_path, 'r') as f:+ schema_sql = f.read()++ conn = self.get_connection()+ conn.executescript(schema_sql)+ conn.commit()+ conn.close()++ # ============================================================================+ # TRADE OPERATIONS+ # ============================================================================++ def record_trade(self, trade_data: Dict[str, Any]) -> int:+ """Record a new trade"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ INSERT INTO agent_trades (+ agent_id, model, symbol, side, order_type, quantity,+ entry_price, stop_loss, take_profit, entry_timestamp,+ reasoning, metadata, execution_time_ms, is_paper_trade+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """, (+ trade_data['agent_id'],+ trade_data['model'],+ trade_data['symbol'],+ trade_data['side'],+ trade_data.get('order_type', 'market'),+ trade_data['quantity'],+ trade_data['entry_price'],+ trade_data.get('stop_loss'),+ trade_data.get('take_profit'),+ trade_data.get('entry_timestamp', int(datetime.now().timestamp())),+ trade_data.get('reasoning'),+ json.dumps(trade_data.get('metadata', {})),+ trade_data.get('execution_time_ms', 0),+ trade_data.get('is_paper_trade', 1)+ ))++ trade_id = cursor.lastrowid+ conn.commit()+ conn.close()++ # Update performance metrics+ self.update_performance_metrics(trade_data['agent_id'])++ return trade_id++ def close_trade(self, trade_id: int, exit_price: float, exit_timestamp: Optional[int] = None):+ """Close an open trade"""+ if exit_timestamp is None:+ exit_timestamp = int(datetime.now().timestamp())++ conn = self.get_connection()+ cursor = conn.cursor()++ # Get trade details+ cursor.execute("SELECT * FROM agent_trades WHERE id = ?", (trade_id,))+ trade = cursor.fetchone()++ if not trade:+ conn.close()+ return++ # Calculate P&L+ quantity = trade['quantity']+ entry_price = trade['entry_price']+ side = trade['side']++ if side == 'buy':+ pnl = (exit_price - entry_price) * quantity+ else: # sell/short+ pnl = (entry_price - exit_price) * quantity++ pnl_percent = (pnl / (entry_price * quantity)) * 100 if (entry_price * quantity) > 0 else 0++ # Update trade+ cursor.execute("""+ UPDATE agent_trades+ SET exit_price = ?, exit_timestamp = ?, pnl = ?, pnl_percent = ?, status = 'closed'+ WHERE id = ?+ """, (exit_price, exit_timestamp, pnl, pnl_percent, trade_id))++ conn.commit()+ conn.close()++ # Update performance metrics+ self.update_performance_metrics(trade['agent_id'])++ def get_agent_trades(self, agent_id: str, limit: int = 100, status: Optional[str] = None) -> List[Dict]:+ """Get trades for an agent"""+ conn = self.get_connection()+ cursor = conn.cursor()++ if status:+ cursor.execute("""+ SELECT * FROM agent_trades+ WHERE agent_id = ? AND status = ?+ ORDER BY entry_timestamp DESC+ LIMIT ?+ """, (agent_id, status, limit))+ else:+ cursor.execute("""+ SELECT * FROM agent_trades+ WHERE agent_id = ?+ ORDER BY entry_timestamp DESC+ LIMIT ?+ """, (agent_id, limit))++ trades = [dict(row) for row in cursor.fetchall()]+ conn.close()++ return trades++ # ============================================================================+ # PERFORMANCE METRICS+ # ============================================================================++ def update_performance_metrics(self, agent_id: str):+ """Recalculate and update performance metrics for an agent"""+ conn = self.get_connection()+ cursor = conn.cursor()++ # Get all closed trades+ cursor.execute("""+ SELECT * FROM agent_trades+ WHERE agent_id = ? AND status = 'closed'+ ORDER BY entry_timestamp ASC+ """, (agent_id,))++ trades = cursor.fetchall()++ if not trades:+ conn.close()+ return++ # Calculate metrics+ total_trades = len(trades)+ winning_trades = len([t for t in trades if t['pnl'] > 0])+ losing_trades = len([t for t in trades if t['pnl'] < 0])++ total_pnl = sum(t['pnl'] for t in trades)++ # Time-based P&L+ now = datetime.now().timestamp()+ day_ago = now - 86400+ week_ago = now - 604800+ month_ago = now - 2592000++ daily_pnl = sum(t['pnl'] for t in trades if t['exit_timestamp'] and t['exit_timestamp'] >= day_ago)+ weekly_pnl = sum(t['pnl'] for t in trades if t['exit_timestamp'] and t['exit_timestamp'] >= week_ago)+ monthly_pnl = sum(t['pnl'] for t in trades if t['exit_timestamp'] and t['exit_timestamp'] >= month_ago)++ win_rate = (winning_trades / total_trades * 100) if total_trades > 0 else 0++ # Win/Loss stats+ wins = [t['pnl'] for t in trades if t['pnl'] > 0]+ losses = [abs(t['pnl']) for t in trades if t['pnl'] < 0]++ avg_win = sum(wins) / len(wins) if wins else 0+ avg_loss = sum(losses) / len(losses) if losses else 0++ largest_win = max(wins) if wins else 0+ largest_loss = max(losses) if losses else 0++ profit_factor = (sum(wins) / sum(losses)) if losses and sum(losses) > 0 else 0++ # Sharpe Ratio (simplified)+ if len(trades) >= 2:+ returns = [t['pnl_percent'] for t in trades]+ avg_return = sum(returns) / len(returns)+ std_dev = (sum((r - avg_return) ** 2 for r in returns) / len(returns)) ** 0.5+ sharpe_ratio = (avg_return / std_dev) if std_dev > 0 else 0+ else:+ sharpe_ratio = 0++ # Drawdown calculation+ cumulative_pnl = []+ running_pnl = 0+ for trade in trades:+ running_pnl += trade['pnl']+ cumulative_pnl.append(running_pnl)++ peak = cumulative_pnl[0]+ max_drawdown = 0+ current_drawdown = 0++ for pnl in cumulative_pnl:+ if pnl > peak:+ peak = pnl+ drawdown = (peak - pnl) / abs(peak) if peak != 0 else 0+ max_drawdown = max(max_drawdown, drawdown)++ if cumulative_pnl:+ current_drawdown = (peak - cumulative_pnl[-1]) / abs(peak) if peak != 0 else 0++ # Consecutive wins/losses+ consecutive_wins = 0+ consecutive_losses = 0+ max_consecutive_wins = 0+ max_consecutive_losses = 0+ current_streak_wins = 0+ current_streak_losses = 0++ for trade in trades:+ if trade['pnl'] > 0:+ current_streak_wins += 1+ current_streak_losses = 0+ max_consecutive_wins = max(max_consecutive_wins, current_streak_wins)+ elif trade['pnl'] < 0:+ current_streak_losses += 1+ current_streak_wins = 0+ max_consecutive_losses = max(max_consecutive_losses, current_streak_losses)++ consecutive_wins = current_streak_wins+ consecutive_losses = current_streak_losses++ # Total volume+ total_volume = sum(t['quantity'] * t['entry_price'] for t in trades)++ # Open positions+ cursor.execute("SELECT COUNT(*) as count FROM agent_trades WHERE agent_id = ? AND status = 'open'", (agent_id,))+ positions = cursor.fetchone()['count']++ # Last trade timestamp+ last_trade_timestamp = trades[-1]['exit_timestamp'] if trades[-1]['exit_timestamp'] else trades[-1]['entry_timestamp']++ # Get model name+ cursor.execute("SELECT model FROM agent_trades WHERE agent_id = ? LIMIT 1", (agent_id,))+ result = cursor.fetchone()+ model = result['model'] if result else 'unknown'++ # Upsert performance metrics+ cursor.execute("""+ INSERT OR REPLACE INTO agent_performance (+ agent_id, model, total_trades, winning_trades, losing_trades,+ total_pnl, daily_pnl, weekly_pnl, monthly_pnl, win_rate,+ sharpe_ratio, sortino_ratio, max_drawdown, current_drawdown,+ avg_win, avg_loss, profit_factor, largest_win, largest_loss,+ consecutive_wins, consecutive_losses, max_consecutive_wins,+ max_consecutive_losses, total_volume, positions, last_trade_timestamp,+ last_updated+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """, (+ agent_id, model, total_trades, winning_trades, losing_trades,+ total_pnl, daily_pnl, weekly_pnl, monthly_pnl, win_rate,+ sharpe_ratio, sharpe_ratio, max_drawdown, current_drawdown,+ avg_win, avg_loss, profit_factor, largest_win, largest_loss,+ consecutive_wins, consecutive_losses, max_consecutive_wins,+ max_consecutive_losses, total_volume, positions, last_trade_timestamp,+ int(datetime.now().timestamp())+ ))++ conn.commit()+ conn.close()++ def get_agent_performance(self, agent_id: str) -> Optional[Dict]:+ """Get performance metrics for an agent"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("SELECT * FROM agent_performance WHERE agent_id = ?", (agent_id,))+ result = cursor.fetchone()++ conn.close()++ return dict(result) if result else None++ def get_leaderboard(self, limit: int = 20) -> List[Dict]:+ """Get leaderboard of all agents sorted by total P&L"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ SELECT * FROM agent_performance+ ORDER BY total_pnl DESC+ LIMIT ?+ """, (limit,))++ leaderboard = [dict(row) for row in cursor.fetchall()]+ conn.close()++ return leaderboard++ # ============================================================================+ # DECISIONS LOG+ # ============================================================================++ def log_decision(self, decision_data: Dict[str, Any]):+ """Log an agent decision for real-time feed"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ INSERT INTO agent_decisions (+ agent_id, model, decision_type, symbol, decision,+ reasoning, confidence, timestamp, execution_time_ms+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)+ """, (+ decision_data['agent_id'],+ decision_data['model'],+ decision_data['decision_type'],+ decision_data.get('symbol'),+ decision_data['decision'],+ decision_data.get('reasoning'),+ decision_data.get('confidence'),+ decision_data.get('timestamp', int(datetime.now().timestamp())),+ decision_data.get('execution_time_ms', 0)+ ))++ conn.commit()+ conn.close()++ def get_recent_decisions(self, limit: int = 50, agent_id: Optional[str] = None) -> List[Dict]:+ """Get recent decisions from all or specific agent"""+ conn = self.get_connection()+ cursor = conn.cursor()++ if agent_id:+ cursor.execute("""+ SELECT * FROM agent_decisions+ WHERE agent_id = ?+ ORDER BY timestamp DESC+ LIMIT ?+ """, (agent_id, limit))+ else:+ cursor.execute("""+ SELECT * FROM agent_decisions+ ORDER BY timestamp DESC+ LIMIT ?+ """, (limit,))++ decisions = [dict(row) for row in cursor.fetchall()]+ conn.close()++ return decisions++ # ============================================================================+ # EVOLUTION+ # ============================================================================++ def log_evolution(self, evolution_data: Dict[str, Any]):+ """Log agent evolution event"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ INSERT INTO agent_evolution (+ agent_id, model, evolution_trigger, old_instructions,+ new_instructions, metrics_before, metrics_after, timestamp, notes+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)+ """, (+ evolution_data['agent_id'],+ evolution_data['model'],+ evolution_data['evolution_trigger'],+ evolution_data.get('old_instructions'),+ evolution_data['new_instructions'],+ json.dumps(evolution_data.get('metrics_before', {})),+ json.dumps(evolution_data.get('metrics_after', {})),+ evolution_data.get('timestamp', int(datetime.now().timestamp())),+ evolution_data.get('notes')+ ))++ conn.commit()+ conn.close()++ def get_evolution_history(self, agent_id: str, limit: int = 10) -> List[Dict]:+ """Get evolution history for an agent"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ SELECT * FROM agent_evolution+ WHERE agent_id = ?+ ORDER BY timestamp DESC+ LIMIT ?+ """, (agent_id, limit))++ history = [dict(row) for row in cursor.fetchall()]+ conn.close()++ return history++ # ============================================================================+ # DEBATE SESSIONS+ # ============================================================================++ def record_debate(self, debate_data: Dict[str, Any]) -> str:+ """Record a debate session"""+ conn = self.get_connection()+ cursor = conn.cursor()++ debate_id = debate_data.get('id', f"debate_{int(datetime.now().timestamp())}")++ cursor.execute("""+ INSERT OR REPLACE INTO debate_sessions (+ id, symbol, bull_model, bear_model, analyst_model,+ bull_argument, bear_argument, analyst_decision,+ final_action, confidence, timestamp, execution_time_ms+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """, (+ debate_id,+ debate_data['symbol'],+ debate_data['bull_model'],+ debate_data['bear_model'],+ debate_data['analyst_model'],+ debate_data.get('bull_argument'),+ debate_data.get('bear_argument'),+ debate_data.get('analyst_decision'),+ debate_data.get('final_action'),+ debate_data.get('confidence'),+ debate_data.get('timestamp', int(datetime.now().timestamp())),+ debate_data.get('execution_time_ms', 0)+ ))++ conn.commit()+ conn.close()++ return debate_id++ def get_recent_debates(self, limit: int = 10) -> List[Dict]:+ """Get recent debate sessions"""+ conn = self.get_connection()+ cursor = conn.cursor()++ cursor.execute("""+ SELECT * FROM debate_sessions+ ORDER BY timestamp DESC+ LIMIT ?+ """, (limit,))++ debates = [dict(row) for row in cursor.fetchall()]+ conn.close()++ return debates+++# Global instance+_db_manager = None++def get_db_manager() -> DatabaseManager:+ """Get singleton database manager instance"""+ global _db_manager+ if _db_manager is None:+ _db_manager = DatabaseManager()+ return _db_managerdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/schema.sql b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/schema.sqlnew file mode 100644index 000000000..83e772e7e--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/db/schema.sql@@ -0,0 +1,127 @@+-- Agno Trading Database Schema+-- Agent Performance Tracking & Trade History++-- Agent Trades Table+CREATE TABLE IF NOT EXISTS agent_trades (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ agent_id TEXT NOT NULL,+ model TEXT NOT NULL,+ symbol TEXT NOT NULL,+ side TEXT NOT NULL, -- 'buy' or 'sell'+ order_type TEXT NOT NULL, -- 'market', 'limit', 'stop'+ quantity REAL NOT NULL,+ entry_price REAL NOT NULL,+ exit_price REAL,+ stop_loss REAL,+ take_profit REAL,+ pnl REAL DEFAULT 0,+ pnl_percent REAL DEFAULT 0,+ status TEXT DEFAULT 'open', -- 'open', 'closed', 'cancelled'+ entry_timestamp INTEGER NOT NULL,+ exit_timestamp INTEGER,+ reasoning TEXT,+ metadata TEXT, -- JSON: strategy, signals, indicators+ execution_time_ms INTEGER,+ is_paper_trade BOOLEAN DEFAULT 1,+ created_at INTEGER DEFAULT (strftime('%s', 'now'))+);++-- Agent Performance Metrics Table+CREATE TABLE IF NOT EXISTS agent_performance (+ agent_id TEXT PRIMARY KEY,+ model TEXT NOT NULL,+ total_trades INTEGER DEFAULT 0,+ winning_trades INTEGER DEFAULT 0,+ losing_trades INTEGER DEFAULT 0,+ total_pnl REAL DEFAULT 0,+ daily_pnl REAL DEFAULT 0,+ weekly_pnl REAL DEFAULT 0,+ monthly_pnl REAL DEFAULT 0,+ win_rate REAL DEFAULT 0,+ sharpe_ratio REAL DEFAULT 0,+ sortino_ratio REAL DEFAULT 0,+ max_drawdown REAL DEFAULT 0,+ current_drawdown REAL DEFAULT 0,+ avg_win REAL DEFAULT 0,+ avg_loss REAL DEFAULT 0,+ profit_factor REAL DEFAULT 0,+ largest_win REAL DEFAULT 0,+ largest_loss REAL DEFAULT 0,+ consecutive_wins INTEGER DEFAULT 0,+ consecutive_losses INTEGER DEFAULT 0,+ max_consecutive_wins INTEGER DEFAULT 0,+ max_consecutive_losses INTEGER DEFAULT 0,+ total_volume REAL DEFAULT 0,+ positions INTEGER DEFAULT 0,+ last_trade_timestamp INTEGER,+ last_updated INTEGER DEFAULT (strftime('%s', 'now'))+);++-- Agent Decisions Log (for real-time feed)+CREATE TABLE IF NOT EXISTS agent_decisions (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ agent_id TEXT NOT NULL,+ model TEXT NOT NULL,+ decision_type TEXT NOT NULL, -- 'analysis', 'signal', 'trade', 'risk'+ symbol TEXT,+ decision TEXT NOT NULL,+ reasoning TEXT,+ confidence REAL,+ timestamp INTEGER NOT NULL,+ execution_time_ms INTEGER+);++-- Competitions Table+CREATE TABLE IF NOT EXISTS competitions (+ id TEXT PRIMARY KEY,+ name TEXT NOT NULL,+ symbol TEXT NOT NULL,+ task_type TEXT NOT NULL,+ participating_models TEXT NOT NULL, -- JSON array+ status TEXT DEFAULT 'active', -- 'active', 'completed', 'cancelled'+ start_timestamp INTEGER NOT NULL,+ end_timestamp INTEGER,+ consensus_action TEXT,+ consensus_confidence REAL,+ results TEXT, -- JSON+ created_at INTEGER DEFAULT (strftime('%s', 'now'))+);++-- Agent Evolution History+CREATE TABLE IF NOT EXISTS agent_evolution (+ id INTEGER PRIMARY KEY AUTOINCREMENT,+ agent_id TEXT NOT NULL,+ model TEXT NOT NULL,+ evolution_trigger TEXT NOT NULL, -- 'performance', 'loss_streak', 'win_streak', 'manual'+ old_instructions TEXT,+ new_instructions TEXT NOT NULL,+ metrics_before TEXT, -- JSON+ metrics_after TEXT, -- JSON+ timestamp INTEGER NOT NULL,+ notes TEXT+);++-- Debate Sessions Table+CREATE TABLE IF NOT EXISTS debate_sessions (+ id TEXT PRIMARY KEY,+ symbol TEXT NOT NULL,+ bull_model TEXT NOT NULL,+ bear_model TEXT NOT NULL,+ analyst_model TEXT NOT NULL,+ bull_argument TEXT,+ bear_argument TEXT,+ analyst_decision TEXT,+ final_action TEXT,+ confidence REAL,+ timestamp INTEGER NOT NULL,+ execution_time_ms INTEGER+);++-- Indexes for Performance+CREATE INDEX IF NOT EXISTS idx_agent_trades_agent ON agent_trades(agent_id);+CREATE INDEX IF NOT EXISTS idx_agent_trades_symbol ON agent_trades(symbol);+CREATE INDEX IF NOT EXISTS idx_agent_trades_status ON agent_trades(status);+CREATE INDEX IF NOT EXISTS idx_agent_trades_timestamp ON agent_trades(entry_timestamp DESC);+CREATE INDEX IF NOT EXISTS idx_agent_decisions_agent ON agent_decisions(agent_id);+CREATE INDEX IF NOT EXISTS idx_agent_decisions_timestamp ON agent_decisions(timestamp DESC);+CREATE INDEX IF NOT EXISTS idx_competitions_status ON competitions(status);diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/tools/market_data.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/tools/market_data.pyindex f80aaecfe..f09ba008c 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/tools/market_data.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading/tools/market_data.py@@ -98,7 +98,9 @@ def get_historical_data("""try:if YFINANCE_AVAILABLE:- ticker = yf.Ticker(symbol)+ # Convert crypto symbols to yfinance format: BTC/USD -> BTC-USD+ yf_symbol = symbol.replace('/', '-')+ ticker = yf.Ticker(yf_symbol)hist = ticker.history(period=period, interval=interval)if hist.empty:diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading_service.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading_service.pyindex 59aaedb31..08e7ec8bd 100644--- a/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading_service.py+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agno_trading_service.py@@ -24,11 +24,33 @@ Commands:import sysimport jsonimport os+import loggingfrom typing import Dict, Any, Optional, List+# Configure logging to output to stderr only (stdout is reserved for JSON responses)+logging.basicConfig(+ level=logging.ERROR,+ format='%(levelname)s: %(message)s',+ stream=sys.stderr,+ force=True+)++# Suppress Agno library logs that go to stdout+# Agno uses loguru which outputs to stdout - we need to disable it+os.environ['LOGURU_LEVEL'] = 'CRITICAL'+os.environ['LOGURU_AUTOINIT'] = 'False'+# Add agno_trading to pathsys.path.insert(0, os.path.join(os.path.dirname(__file__), 'agno_trading'))+# Disable loguru after import+try:+ from loguru import logger+ logger.remove() # Remove all default handlers+ logger.add(sys.stderr, level="CRITICAL") # Only critical errors to stderr+except ImportError:+ pass+# Import after path is setfrom config.settings import AgnoConfig, LLMConfig, LLMProvider, TradingConfig, TradingModefrom config.models import list_available_models, get_best_model_for_task, validate_model_config@@ -153,10 +175,16 @@ def run_agent_command(agent_id: str, prompt: str, session_id: Optional[str] = Nodef analyze_market_command(symbol: str,agent_model: str = "openai:gpt-4o-mini",- analysis_type: str = "comprehensive"+ analysis_type: str = "comprehensive",+ api_keys_json: str = "{}") -> str:"""Analyze market for a given symbol"""try:+ # Parse API keys and set environment variables+ api_keys = json.loads(api_keys_json)+ for key, value in api_keys.items():+ os.environ[key] = value+# Parse model stringif ":" in agent_model:model_provider, model_name = agent_model.split(":", 1)@@ -164,9 +192,26 @@ def analyze_market_command(model_provider = "openai"model_name = agent_model+ # Normalize provider name (gemini -> google for Agno)+ normalized_provider = model_provider.lower()+ if normalized_provider == "gemini":+ normalized_provider = "google"++ # Validate API key is configured for the selected provider+ # Check both original and normalized provider names+ required_keys = [+ f"{model_provider.upper()}_API_KEY",+ f"{normalized_provider.upper()}_API_KEY"+ ]+ if not any(key in api_keys and api_keys[key] for key in required_keys):+ return create_response(+ False,+ error=f"API key not configured for {model_provider}. Please configure {model_provider.upper()}_API_KEY or {normalized_provider.upper()}_API_KEY in Settings → LLM Config."+ )+# Create market analyst agentanalyst = MarketAnalystAgent(- model_provider=model_provider,+ model_provider=normalized_provider,model_name=model_name,symbols=[symbol])@@ -183,10 +228,16 @@ def generate_trade_signal_command(symbol: str,strategy: str = "momentum",agent_model: str = "anthropic:claude-sonnet-4",- market_data: Optional[str] = None+ market_data: Optional[str] = None,+ api_keys_json: str = "{}") -> str:"""Generate trading signal"""try:+ # Parse API keys and set environment variables+ api_keys = json.loads(api_keys_json)+ for key, value in api_keys.items():+ os.environ[key] = value+# Parse model stringif ":" in agent_model:model_provider, model_name = agent_model.split(":", 1)@@ -194,9 +245,25 @@ def generate_trade_signal_command(model_provider = "anthropic"model_name = agent_model+ # Normalize provider name (gemini -> google for Agno)+ normalized_provider = model_provider.lower()+ if normalized_provider == "gemini":+ normalized_provider = "google"++ # Validate API key is configured for the selected provider+ required_keys = [+ f"{model_provider.upper()}_API_KEY",+ f"{normalized_provider.upper()}_API_KEY"+ ]+ if not any(key in api_keys and api_keys[key] for key in required_keys):+ return create_response(+ False,+ error=f"API key not configured for {model_provider}. Please configure {model_provider.upper()}_API_KEY or {normalized_provider.upper()}_API_KEY in Settings → LLM Config."+ )+# Create trading strategy agentstrategist = TradingStrategyAgent(- model_provider=model_provider,+ model_provider=normalized_provider,model_name=model_name,symbols=[symbol])@@ -212,10 +279,16 @@ def generate_trade_signal_command(def manage_risk_command(portfolio_data: str,agent_model: str = "openai:gpt-4",- risk_tolerance: str = "moderate"+ risk_tolerance: str = "moderate",+ api_keys_json: str = "{}") -> str:"""Run risk management analysis"""try:+ # Parse API keys and set environment variables+ api_keys = json.loads(api_keys_json)+ for key, value in api_keys.items():+ os.environ[key] = value+portfolio = json.loads(portfolio_data)# Parse model string@@ -225,9 +298,25 @@ def manage_risk_command(model_provider = "openai"model_name = agent_model+ # Normalize provider name (gemini -> google for Agno)+ normalized_provider = model_provider.lower()+ if normalized_provider == "gemini":+ normalized_provider = "google"++ # Validate API key is configured for the selected provider+ required_keys = [+ f"{model_provider.upper()}_API_KEY",+ f"{normalized_provider.upper()}_API_KEY"+ ]+ if not any(key in api_keys and api_keys[key] for key in required_keys):+ return create_response(+ False,+ error=f"API key not configured for {model_provider}. Please configure {model_provider.upper()}_API_KEY or {normalized_provider.upper()}_API_KEY in Settings → LLM Config."+ )+# Create risk manager agentrisk_manager = RiskManagerAgent(- model_provider=model_provider,+ model_provider=normalized_provider,model_name=model_name,risk_tolerance=risk_tolerance)@@ -279,7 +368,8 @@ def get_config_template_command(config_type: str = "default") -> str:def create_competition_command(name: str,models_json: str,- task_type: str = "trading"+ task_type: str = "trading",+ api_keys_json: str = "{}") -> str:"""Create multi-model competition@@ -288,6 +378,7 @@ def create_competition_command(name: Competition namemodels_json: JSON array of models ["openai:gpt-4", "anthropic:claude-sonnet-4"]task_type: Type of task+ api_keys_json: JSON object of API keys (optional)"""try:import json@@ -295,17 +386,29 @@ def create_competition_command(from agno_trading.core.agent_manager import AgentManagermodels = json.loads(models_json)+ api_keys = json.loads(api_keys_json)++ # Set API keys in environment if provided+ if api_keys:+ import os+ for key, value in api_keys.items():+ os.environ[key] = value+manager = AgentManager()orchestrator = TeamOrchestrator()# Create agents for each model+ from agno_trading.core.base_agent import AgentConfig+agents = []for model_str in models:- agent_config = {- "name": f"Agent-{model_str}",- "role": "Market Analyst",- "agent_model": model_str- }+ # Create proper AgentConfig object (not dict)+ agent_config = AgentConfig(+ name=f"Agent-{model_str.replace(':', '-')}",+ role="Market Analyst",+ agent_model=model_str,+ instructions=["Analyze market data and provide trading insights."]+ )agent_id = manager.create_agent(agent_config)agent = manager.get_agent(agent_id)@@ -325,7 +428,12 @@ def create_competition_command(return create_response(False, error=str(e))-def run_competition_command(team_id: str, symbol: str, task: str = "analyze") -> str:+def run_competition_command(+ team_id: str,+ symbol: str,+ task: str = "analyze",+ api_keys_json: str = "{}"+) -> str:"""Run multi-model competition@@ -333,11 +441,20 @@ def run_competition_command(team_id: str, symbol: str, task: str = "analyze") ->team_id: Competition IDsymbol: Trading symboltask: Task type (analyze, signal)+ api_keys_json: JSON object of API keys (optional)"""try:import asyncio+ import jsonfrom agno_trading.core.team_orchestrator import TeamOrchestrator+ # Set API keys in environment if provided+ api_keys = json.loads(api_keys_json)+ if api_keys:+ import os+ for key, value in api_keys.items():+ os.environ[key] = value+orchestrator = TeamOrchestrator()# Build prompt based on task@@ -385,6 +502,210 @@ def get_recent_decisions_command(limit: int = 50) -> str:return create_response(False, error=str(e))+# ============================================================================+# NEW COMMANDS: Auto-Trading, Debate, Evolution+# ============================================================================++def execute_trade_command(+ signal_json: str,+ portfolio_json: str,+ agent_id: str,+ model: str,+ api_keys_json: str = "{}"+) -> str:+ """Execute a trade based on signal"""+ try:+ from agno_trading.core.trade_executor import get_trade_executor++ signal = json.loads(signal_json)+ portfolio = json.loads(portfolio_json)+ api_keys = json.loads(api_keys_json)++ # Set API keys+ for key, value in api_keys.items():+ os.environ[key] = value++ executor = get_trade_executor()+ result = executor.execute_trade(signal, portfolio, agent_id, model, paper_trading=True)++ return create_response(True, result)+ except Exception as e:+ return create_response(False, error=str(e))+++def close_position_command(trade_id: int, exit_price: float, reason: str = "manual") -> str:+ """Close an open position"""+ try:+ from agno_trading.core.trade_executor import get_trade_executor++ executor = get_trade_executor()+ result = executor.close_position(int(trade_id), float(exit_price), reason)++ return create_response(True, result)+ except Exception as e:+ return create_response(False, error=str(e))+++def get_agent_trades_command(agent_id: str, limit: int = 100, status: str = None) -> str:+ """Get trade history for an agent"""+ try:+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ trades = db.get_agent_trades(agent_id, int(limit), status)++ return create_response(True, {"trades": trades})+ except Exception as e:+ return create_response(False, error=str(e))+++def get_agent_performance_command(agent_id: str) -> str:+ """Get performance metrics for an agent"""+ try:+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ performance = db.get_agent_performance(agent_id)++ if performance:+ return create_response(True, {"performance": performance})+ else:+ return create_response(False, error="Agent performance not found")+ except Exception as e:+ return create_response(False, error=str(e))+++def get_db_leaderboard_command(limit: int = 20) -> str:+ """Get leaderboard from database"""+ try:+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ leaderboard = db.get_leaderboard(int(limit))++ return create_response(True, {"leaderboard": leaderboard})+ except Exception as e:+ return create_response(False, error=str(e))+++def get_db_decisions_command(limit: int = 50, agent_id: str = None) -> str:+ """Get recent decisions from database"""+ try:+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ decisions = db.get_recent_decisions(int(limit), agent_id)++ return create_response(True, {"decisions": decisions})+ except Exception as e:+ return create_response(False, error=str(e))+++def run_debate_command(+ symbol: str,+ market_data_json: str,+ bull_model: str,+ bear_model: str,+ analyst_model: str,+ api_keys_json: str = "{}"+) -> str:+ """Run a Bull/Bear/Analyst debate"""+ try:+ from agno_trading.core.debate_orchestrator import get_debate_orchestrator++ market_data = json.loads(market_data_json)+ api_keys = json.loads(api_keys_json)++ # Set API keys+ for key, value in api_keys.items():+ os.environ[key] = value++ orchestrator = get_debate_orchestrator()+ result = orchestrator.run_debate(+ symbol,+ market_data,+ bull_model,+ bear_model,+ analyst_model,+ api_keys+ )++ return create_response(True, result)+ except Exception as e:+ return create_response(False, error=str(e))+++def get_recent_debates_command(limit: int = 10) -> str:+ """Get recent debate sessions"""+ try:+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ debates = db.get_recent_debates(int(limit))++ return create_response(True, {"debates": debates})+ except Exception as e:+ return create_response(False, error=str(e))+++def evolve_agent_command(+ agent_id: str,+ model: str,+ current_instructions_json: str,+ trigger: str,+ notes: str = None+) -> str:+ """Evolve an agent based on performance"""+ try:+ from agno_trading.core.agent_evolution import get_agent_evolution++ current_instructions = json.loads(current_instructions_json)++ evolution = get_agent_evolution()+ result = evolution.evolve_agent(agent_id, model, current_instructions, trigger, notes)++ return create_response(True, result)+ except Exception as e:+ return create_response(False, error=str(e))+++def check_evolution_command(agent_id: str) -> str:+ """Check if agent should evolve"""+ try:+ from agno_trading.core.agent_evolution import get_agent_evolution+ from agno_trading.db.database_manager import get_db_manager++ db = get_db_manager()+ performance = db.get_agent_performance(agent_id)++ if not performance:+ return create_response(False, error="Agent performance not found")++ evolution = get_agent_evolution()+ should_evolve, trigger = evolution.should_evolve(agent_id, performance)++ return create_response(True, {+ "should_evolve": should_evolve,+ "trigger": trigger,+ "performance": performance+ })+ except Exception as e:+ return create_response(False, error=str(e))+++def get_evolution_summary_command(agent_id: str) -> str:+ """Get evolution summary for an agent"""+ try:+ from agno_trading.core.agent_evolution import get_agent_evolution++ evolution = get_agent_evolution()+ summary = evolution.get_evolution_summary(agent_id)++ return create_response(True, summary)+ except Exception as e:+ return create_response(False, error=str(e))++# Command dispatcherCOMMANDS = {"list_models": list_models_command,@@ -400,6 +721,18 @@ COMMANDS = {"run_competition": run_competition_command,"get_leaderboard": get_leaderboard_command,"get_recent_decisions": get_recent_decisions_command,+ # New commands+ "execute_trade": execute_trade_command,+ "close_position": close_position_command,+ "get_agent_trades": get_agent_trades_command,+ "get_agent_performance": get_agent_performance_command,+ "get_db_leaderboard": get_db_leaderboard_command,+ "get_db_decisions": get_db_decisions_command,+ "run_debate": run_debate_command,+ "get_recent_debates": get_recent_debates_command,+ "evolve_agent": evolve_agent_command,+ "check_evolution": check_evolution_command,+ "get_evolution_summary": get_evolution_summary_command,}diff --git a/fincept-terminal-desktop/src-tauri/src/commands/agno_trading.rs b/fincept-terminal-desktop/src-tauri/src/commands/agno_trading.rsindex 3b8612236..7a1149711 100644--- a/fincept-terminal-desktop/src-tauri/src/commands/agno_trading.rs+++ b/fincept-terminal-desktop/src-tauri/src/commands/agno_trading.rs@@ -87,6 +87,7 @@ pub async fn agno_analyze_market(symbol: String,agent_model: Option<String>,analysis_type: Option<String>,+ api_keys_json: Option<String>,) -> Result<String, String> {let mut args = vec!["analyze_market".to_string(), symbol];@@ -102,6 +103,13 @@ pub async fn agno_analyze_market(args.push("comprehensive".to_string());}+ // Pass API keys as JSON string+ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }+execute_python_command(&app, "agno_trading_service.py", &args)}@@ -113,6 +121,7 @@ pub async fn agno_generate_trade_signal(strategy: Option<String>,agent_model: Option<String>,market_data: Option<String>,+ api_keys_json: Option<String>,) -> Result<String, String> {let mut args = vec!["generate_trade_signal".to_string(), symbol];@@ -130,6 +139,15 @@ pub async fn agno_generate_trade_signal(if let Some(data) = market_data {args.push(data);+ } else {+ args.push("null".to_string());+ }++ // Pass API keys as JSON string+ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());}execute_python_command(&app, "agno_trading_service.py", &args)@@ -142,6 +160,7 @@ pub async fn agno_manage_risk(portfolio_data: String,agent_model: Option<String>,risk_tolerance: Option<String>,+ api_keys_json: Option<String>,) -> Result<String, String> {let mut args = vec!["manage_risk".to_string(), portfolio_data];@@ -157,6 +176,13 @@ pub async fn agno_manage_risk(args.push("moderate".to_string());}+ // Pass API keys as JSON string+ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }+execute_python_command(&app, "agno_trading_service.py", &args)}@@ -184,6 +210,7 @@ pub async fn agno_create_competition(name: String,models_json: String,task_type: Option<String>,+ api_keys_json: Option<String>,) -> Result<String, String> {let mut args = vec!["create_competition".to_string(), name, models_json];@@ -193,6 +220,13 @@ pub async fn agno_create_competition(args.push("trading".to_string());}+ // Pass API keys as JSON string+ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }+execute_python_command(&app, "agno_trading_service.py", &args)}@@ -203,6 +237,7 @@ pub async fn agno_run_competition(team_id: String,symbol: String,task: Option<String>,+ api_keys_json: Option<String>,) -> Result<String, String> {let mut args = vec!["run_competition".to_string(), team_id, symbol];@@ -212,6 +247,13 @@ pub async fn agno_run_competition(args.push("analyze".to_string());}+ // Pass API keys as JSON string+ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }+execute_python_command(&app, "agno_trading_service.py", &args)}@@ -240,3 +282,220 @@ pub async fn agno_get_recent_decisions(execute_python_command(&app, "agno_trading_service.py", &args)}++// ============================================================================+// NEW COMMANDS: Auto-Trading, Debate, Evolution+// ============================================================================++/// Execute a trade based on signal+#[tauri::command]+pub async fn agno_execute_trade(+ app: tauri::AppHandle,+ signal_json: String,+ portfolio_json: String,+ agent_id: String,+ model: String,+ api_keys_json: Option<String>,+) -> Result<String, String> {+ let mut args = vec![+ "execute_trade".to_string(),+ signal_json,+ portfolio_json,+ agent_id,+ model,+ ];++ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Close an open position+#[tauri::command]+pub async fn agno_close_position(+ app: tauri::AppHandle,+ trade_id: i32,+ exit_price: f64,+ reason: Option<String>,+) -> Result<String, String> {+ let mut args = vec![+ "close_position".to_string(),+ trade_id.to_string(),+ exit_price.to_string(),+ ];++ if let Some(r) = reason {+ args.push(r);+ } else {+ args.push("manual".to_string());+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get trade history for an agent+#[tauri::command]+pub async fn agno_get_agent_trades(+ app: tauri::AppHandle,+ agent_id: String,+ limit: Option<i32>,+ status: Option<String>,+) -> Result<String, String> {+ let mut args = vec!["get_agent_trades".to_string(), agent_id];++ if let Some(l) = limit {+ args.push(l.to_string());+ } else {+ args.push("100".to_string());+ }++ if let Some(s) = status {+ args.push(s);+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get performance metrics for an agent+#[tauri::command]+pub async fn agno_get_agent_performance(+ app: tauri::AppHandle,+ agent_id: String,+) -> Result<String, String> {+ let args = vec!["get_agent_performance".to_string(), agent_id];+ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get leaderboard from database+#[tauri::command]+pub async fn agno_get_db_leaderboard(+ app: tauri::AppHandle,+ limit: Option<i32>,+) -> Result<String, String> {+ let mut args = vec!["get_db_leaderboard".to_string()];++ if let Some(l) = limit {+ args.push(l.to_string());+ } else {+ args.push("20".to_string());+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get recent decisions from database+#[tauri::command]+pub async fn agno_get_db_decisions(+ app: tauri::AppHandle,+ limit: Option<i32>,+ agent_id: Option<String>,+) -> Result<String, String> {+ let mut args = vec!["get_db_decisions".to_string()];++ if let Some(l) = limit {+ args.push(l.to_string());+ } else {+ args.push("50".to_string());+ }++ if let Some(id) = agent_id {+ args.push(id);+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Run a Bull/Bear/Analyst debate+#[tauri::command]+pub async fn agno_run_debate(+ app: tauri::AppHandle,+ symbol: String,+ market_data_json: String,+ bull_model: String,+ bear_model: String,+ analyst_model: String,+ api_keys_json: Option<String>,+) -> Result<String, String> {+ let mut args = vec![+ "run_debate".to_string(),+ symbol,+ market_data_json,+ bull_model,+ bear_model,+ analyst_model,+ ];++ if let Some(keys) = api_keys_json {+ args.push(keys);+ } else {+ args.push("{}".to_string());+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get recent debate sessions+#[tauri::command]+pub async fn agno_get_recent_debates(+ app: tauri::AppHandle,+ limit: Option<i32>,+) -> Result<String, String> {+ let mut args = vec!["get_recent_debates".to_string()];++ if let Some(l) = limit {+ args.push(l.to_string());+ } else {+ args.push("10".to_string());+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Evolve an agent based on performance+#[tauri::command]+pub async fn agno_evolve_agent(+ app: tauri::AppHandle,+ agent_id: String,+ model: String,+ current_instructions_json: String,+ trigger: String,+ notes: Option<String>,+) -> Result<String, String> {+ let mut args = vec![+ "evolve_agent".to_string(),+ agent_id,+ model,+ current_instructions_json,+ trigger,+ ];++ if let Some(n) = notes {+ args.push(n);+ }++ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Check if agent should evolve+#[tauri::command]+pub async fn agno_check_evolution(+ app: tauri::AppHandle,+ agent_id: String,+) -> Result<String, String> {+ let args = vec!["check_evolution".to_string(), agent_id];+ execute_python_command(&app, "agno_trading_service.py", &args)+}++/// Get evolution summary for an agent+#[tauri::command]+pub async fn agno_get_evolution_summary(+ app: tauri::AppHandle,+ agent_id: String,+) -> Result<String, String> {+ let args = vec!["get_evolution_summary".to_string(), agent_id];+ execute_python_command(&app, "agno_trading_service.py", &args)+}diff --git a/fincept-terminal-desktop/src-tauri/src/lib.rs b/fincept-terminal-desktop/src-tauri/src/lib.rsindex b7d626e67..58047bb7e 100644--- a/fincept-terminal-desktop/src-tauri/src/lib.rs+++ b/fincept-terminal-desktop/src-tauri/src/lib.rs@@ -1078,7 +1078,19 @@ pub fn run() {commands::agno_trading::agno_create_competition,commands::agno_trading::agno_run_competition,commands::agno_trading::agno_get_leaderboard,- commands::agno_trading::agno_get_recent_decisions+ commands::agno_trading::agno_get_recent_decisions,+ // New commands: Auto-Trading, Debate, Evolution+ commands::agno_trading::agno_execute_trade,+ commands::agno_trading::agno_close_position,+ commands::agno_trading::agno_get_agent_trades,+ commands::agno_trading::agno_get_agent_performance,+ commands::agno_trading::agno_get_db_leaderboard,+ commands::agno_trading::agno_get_db_decisions,+ commands::agno_trading::agno_run_debate,+ commands::agno_trading::agno_get_recent_debates,+ commands::agno_trading::agno_evolve_agent,+ commands::agno_trading::agno_check_evolution,+ commands::agno_trading::agno_get_evolution_summary]).run(tauri::generate_context!()).expect("error while running tauri application");diff --git a/fincept-terminal-desktop/src-tauri/src/utils/python.rs b/fincept-terminal-desktop/src-tauri/src/utils/python.rsindex f02a24440..4779b4727 100644--- a/fincept-terminal-desktop/src-tauri/src/utils/python.rs+++ b/fincept-terminal-desktop/src-tauri/src/utils/python.rs@@ -237,9 +237,57 @@ pub fn execute_python_command(if output.status.success() {let stdout = String::from_utf8_lossy(&output.stdout);- Ok(stdout.to_string())++ // Filter out log lines (ERROR, WARNING, INFO, DEBUG) and keep only JSON+ // Log lines typically start with log level keywords+ let filtered_output: Vec<&str> = stdout+ .lines()+ .filter(|line| {+ let trimmed = line.trim();+ // Skip empty lines+ if trimmed.is_empty() {+ return false;+ }+ // Skip lines that start with log level indicators+ if trimmed.starts_with("ERROR")+ || trimmed.starts_with("WARNING")+ || trimmed.starts_with("INFO")+ || trimmed.starts_with("DEBUG")+ || trimmed.starts_with("TRACE") {+ return false;+ }+ // Skip continuation lines (lines that are indented)+ if line.starts_with(" ") || line.starts_with("\t") {+ return false;+ }+ // Keep everything else (JSON output)+ true+ })+ .collect();++ Ok(filtered_output.join("\n"))} else {+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);- Err(format!("Command failed: {}", stderr))++ // Build detailed error message+ let mut error_msg = format!("Command failed with exit code: {:?}\n\n", output.status.code());++ if !stderr.is_empty() {+ error_msg.push_str(&format!("STDERR:\n{}\n\n", stderr));+ }++ if !stdout.is_empty() {+ error_msg.push_str(&format!("STDOUT:\n{}\n\n", stdout));+ }++ if stderr.is_empty() && stdout.is_empty() {+ error_msg.push_str("No output was produced by the Python script.\n");+ error_msg.push_str(&format!("Script: {}\n", script_path.display()));+ error_msg.push_str(&format!("Python: {}\n", python_path.display()));+ error_msg.push_str(&format!("Args: {:?}", args));+ }++ Err(error_msg)}}diff --git a/fincept-terminal-desktop/src/components/tabs/AgentConfigTab.tsx b/fincept-terminal-desktop/src/components/tabs/AgentConfigTab.tsxindex 03c615402..523bbcf48 100644--- a/fincept-terminal-desktop/src/components/tabs/AgentConfigTab.tsx+++ b/fincept-terminal-desktop/src/components/tabs/AgentConfigTab.tsx@@ -3,6 +3,7 @@import React, { useState, useEffect } from 'react';import { invoke } from '@tauri-apps/api/core';+import ReactMarkdown from 'react-markdown';import {Bot,Brain,@@ -18,7 +19,9 @@ import {Database,Eye,EyeOff,+ Key,} from 'lucide-react';+import { sqliteService, type LLMConfig } from '@/services/sqliteService';// Bloomberg Professional Color Paletteconst BLOOMBERG = {@@ -45,6 +48,7 @@ interface AgentConfig {role: string;goal: string;description: string;+ book_source?: string;llm_config: {provider: string;model_id: string;@@ -74,6 +78,12 @@ const AgentConfigTab: React.FC = () => {const [showJsonEditor, setShowJsonEditor] = useState(false);const [error, setError] = useState<string | null>(null);const [success, setSuccess] = useState<string | null>(null);+ const [llmConfigs, setLlmConfigs] = useState<LLMConfig[]>([]);+ const [apiKeys, setApiKeys] = useState<Record<string, string>>({});+ const [testQuery, setTestQuery] = useState('Analyze China-Russia alliance dynamics');+ const [expandedBooks, setExpandedBooks] = useState<Set<string>>(new Set());+ const [teamName, setTeamName] = useState<string | null>(null);+ const [selectedBook, setSelectedBook] = useState<string | null>(null);const categories = [{ id: 'TraderInvestorsAgent', name: 'Trader/Investor Agents', icon: '💰' },@@ -86,8 +96,27 @@ const AgentConfigTab: React.FC = () => {useEffect(() => {loadAgents();loadProviders();+ loadLLMConfigs();}, [selectedCategory]);+ const loadLLMConfigs = async () => {+ try {+ const configs = await sqliteService.getLLMConfigs();+ setLlmConfigs(configs);++ // Build API keys map+ const keys: Record<string, string> = {};+ configs.forEach(config => {+ if (config.api_key) {+ keys[`${config.provider.toUpperCase()}_API_KEY`] = config.api_key;+ }+ });+ setApiKeys(keys);+ } catch (err) {+ console.error('Failed to load LLM configs:', err);+ }+ };+// Update JSON when selected agent changesuseEffect(() => {if (selectedAgent) {@@ -108,6 +137,7 @@ const AgentConfigTab: React.FC = () => {const data = result as any;if (data.success) {setAgents(data.agents || []);+ setTeamName(data.team_name || null);if (data.agents && data.agents.length > 0) {setSelectedAgent(data.agents[0]);}@@ -177,6 +207,17 @@ const AgentConfigTab: React.FC = () => {const testAgent = async () => {if (!selectedAgent) return;+ if (!testQuery.trim()) {+ setError('Please enter a test query');+ return;+ }++ // Get active LLM config from Settings+ const activeLLM = llmConfigs.find(c => c.is_active);+ if (!activeLLM) {+ setError('No active LLM provider configured in Settings. Please configure and activate an LLM provider.');+ return;+ }setLoading(true);setError(null);@@ -187,10 +228,14 @@ const AgentConfigTab: React.FC = () => {parameters: {agent_id: selectedAgent.id,category: selectedCategory,- query: 'Test query: Provide a brief summary of your role and capabilities.',+ query: testQuery,},inputs: {- api_keys: {}, // User would need to provide API keys+ api_keys: apiKeys,+ llm_override: {+ provider: activeLLM.provider,+ model: activeLLM.model,+ },},});@@ -204,6 +249,66 @@ const AgentConfigTab: React.FC = () => {}};+ const testTeamCollaboration = async () => {+ if (!testQuery.trim()) {+ setError('Please enter a test query');+ return;+ }++ const activeLLM = llmConfigs.find(c => c.is_active);+ if (!activeLLM) {+ setError('No active LLM provider configured in Settings.');+ return;+ }++ // Get agents for selected book only+ const bookAgents = selectedBook+ ? agents.filter(a => a.book_source === selectedBook)+ : agents;++ const agentIds = bookAgents.map(a => a.id);++ setLoading(true);+ setError(null);+ setTestResult({+ success: true,+ discussion: [],+ total_agents: bookAgents.length,+ rounds: 2,+ query: testQuery+ });++ try {+ const result = await invoke('execute_python_agent_command', {+ action: 'execute_team_collaboration',+ parameters: {+ category: selectedCategory,+ query: testQuery,+ agent_ids: agentIds, // Send only selected book's agents+ },+ inputs: {+ api_keys: apiKeys,+ llm_override: {+ provider: activeLLM.provider,+ model: activeLLM.model,+ },+ },+ });++ const data = result as any;+ setTestResult(data);++ if (!data.success) {+ setError(data.error || 'Team collaboration failed');+ }+ } catch (err: any) {+ console.error('Team collaboration failed:', err);+ setError(err.toString());+ } finally {+ setLoading(false);+ }+ };+return (<div style={{height: '100%',@@ -282,6 +387,21 @@ const AgentConfigTab: React.FC = () => {</div><div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>+ {/* API Keys Indicator */}+ <div style={{+ padding: '4px 10px',+ backgroundColor: BLOOMBERG.PANEL_BG,+ border: `1px solid ${Object.keys(apiKeys).length > 0 ? BLOOMBERG.GREEN : BLOOMBERG.RED}`,+ fontSize: '9px',+ display: 'flex',+ alignItems: 'center',+ gap: '4px',+ color: Object.keys(apiKeys).length > 0 ? BLOOMBERG.GREEN : BLOOMBERG.RED+ }}>+ <Key size={10} />+ {Object.keys(apiKeys).length} API Keys+ </div>+<buttononClick={() => setShowJsonEditor(!showJsonEditor)}style={{@@ -327,7 +447,7 @@ const AgentConfigTab: React.FC = () => {<div style={{ flex: 1, display: 'flex', overflow: 'hidden' }}>{/* Left Panel - Agent List */}<div style={{- width: '280px',+ width: '260px',borderRight: `1px solid ${BLOOMBERG.BORDER}`,display: 'flex',flexDirection: 'column',@@ -341,7 +461,7 @@ const AgentConfigTab: React.FC = () => {fontWeight: 600,color: BLOOMBERG.GRAY}}>- AVAILABLE AGENTS ({agents.length})+ {teamName ? `TEAM: ${teamName.toUpperCase()} (${agents.length})` : `AVAILABLE AGENTS (${agents.length})`}</div><div style={{ flex: 1, overflow: 'auto', padding: '8px' }}>@@ -356,7 +476,21 @@ const AgentConfigTab: React.FC = () => {<div style={{ marginTop: '8px', fontSize: '10px' }}>No agents found</div></div>) : (- agents.map((agent) => (+ <>+ {(() => {+ // Group agents by book_source+ const grouped = agents.reduce((acc, agent) => {+ const book = agent.book_source || 'Other';+ if (!acc[book]) acc[book] = [];+ acc[book].push(agent);+ return acc;+ }, {} as Record<string, AgentConfig[]>);++ const books = Object.keys(grouped);++ // If only one agent or no books, show flat list+ if (books.length <= 1 && !teamName) {+ return agents.map((agent) => (<buttonkey={agent.id}onClick={() => setSelectedAgent(agent)}@@ -414,13 +548,111 @@ const AgentConfigTab: React.FC = () => {</span></div></button>- ))+ ));+ }++ // Show book groups+ return books.map(bookName => {+ const bookAgents = grouped[bookName];+ const isExpanded = expandedBooks.has(bookName);++ return (+ <div key={bookName} style={{ marginBottom: '8px' }}>+ {/* Book Header */}+ <button+ onClick={() => {+ const newExpanded = new Set(expandedBooks);+ if (isExpanded) {+ newExpanded.delete(bookName);+ } else {+ newExpanded.add(bookName);+ }+ setExpandedBooks(newExpanded);+ setSelectedBook(isExpanded ? null : bookName);+ }}+ style={{+ width: '100%',+ padding: '10px',+ backgroundColor: isExpanded ? BLOOMBERG.ORANGE + '20' : BLOOMBERG.HEADER_BG,+ border: `1px solid ${isExpanded ? BLOOMBERG.ORANGE : BLOOMBERG.BORDER}`,+ color: BLOOMBERG.WHITE,+ cursor: 'pointer',+ textAlign: 'left',+ fontSize: '10px',+ fontWeight: 600,+ marginBottom: isExpanded ? '6px' : '0'+ }}+ >+ <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <span style={{ fontSize: '14px' }}>📖</span>+ <span style={{ color: BLOOMBERG.ORANGE }}>{bookName}</span>+ </div>+ <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>+ <span style={{ color: BLOOMBERG.GRAY, fontSize: '9px' }}>+ {bookAgents.length} agents+ </span>+ <ChevronDown+ size={14}+ style={{+ transform: isExpanded ? 'rotate(180deg)' : 'rotate(0deg)',+ transition: 'transform 0.2s'+ }}+ />+ </div>+ </div>+ </button>++ {/* Expanded Agents */}+ {isExpanded && bookAgents.map((agent) => (+ <button+ key={agent.id}+ onClick={() => setSelectedAgent(agent)}+ style={{+ width: 'calc(100% - 12px)',+ padding: '10px',+ marginBottom: '6px',+ marginLeft: '12px',+ backgroundColor: selectedAgent?.id === agent.id ? BLOOMBERG.HOVER : 'transparent',+ border: `1px solid ${selectedAgent?.id === agent.id ? BLOOMBERG.CYAN : BLOOMBERG.BORDER}`,+ color: BLOOMBERG.WHITE,+ cursor: 'pointer',+ textAlign: 'left',+ fontSize: '10px',+ transition: 'all 0.2s'+ }}+ onMouseEnter={(e) => {+ if (selectedAgent?.id !== agent.id) {+ e.currentTarget.style.backgroundColor = BLOOMBERG.HOVER;+ e.currentTarget.style.borderColor = BLOOMBERG.MUTED;+ }+ }}+ onMouseLeave={(e) => {+ if (selectedAgent?.id !== agent.id) {+ e.currentTarget.style.backgroundColor = 'transparent';+ e.currentTarget.style.borderColor = BLOOMBERG.BORDER;+ }+ }}+ >+ <div style={{ fontWeight: 600, color: BLOOMBERG.CYAN, marginBottom: '4px' }}>+ {agent.name}+ </div>+ <div style={{ color: BLOOMBERG.GRAY, fontSize: '9px' }}>+ {agent.role}+ </div>+ </button>+ ))}+ </div>+ );+ });+ })()}+ </>)}</div></div>- {/* Right Panel - Configuration Editor */}- <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>+ {/* Middle Panel - Configuration Editor */}+ <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden', borderRight: testResult ? `1px solid ${BLOOMBERG.BORDER}` : 'none' }}>{/* Status Messages */}{(error || success) && (<div style={{@@ -453,7 +685,32 @@ const AgentConfigTab: React.FC = () => {<div style={{ fontSize: '10px', color: BLOOMBERG.GRAY, marginBottom: '8px' }}>{selectedAgent.description}</div>- <div style={{ display: 'flex', gap: '8px' }}>++ {/* Test Query Input */}+ <div style={{ marginBottom: '8px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ TEST QUERY+ </div>+ <textarea+ value={testQuery}+ onChange={(e) => setTestQuery(e.target.value)}+ placeholder="Enter your test query here..."+ style={{+ width: '100%',+ minHeight: '60px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ color: BLOOMBERG.WHITE,+ padding: '6px 8px',+ fontSize: '10px',+ fontFamily: 'inherit',+ resize: 'vertical',+ outline: 'none'+ }}+ />+ </div>++ <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}><buttononClick={saveConfig}disabled={loading}@@ -491,8 +748,30 @@ const AgentConfigTab: React.FC = () => {}}><Play size={12} />- Test Agent+ {loading ? 'Testing...' : 'Test Agent'}</button>++ {(teamName || (selectedBook && agents.filter(a => a.book_source === selectedBook).length > 1)) && (+ <button+ onClick={testTeamCollaboration}+ disabled={loading}+ style={{+ padding: '6px 12px',+ backgroundColor: BLOOMBERG.PURPLE,+ border: 'none',+ color: BLOOMBERG.WHITE,+ cursor: loading ? 'not-allowed' : 'pointer',+ fontSize: '10px',+ fontWeight: 600,+ display: 'flex',+ alignItems: 'center',+ gap: '4px'+ }}+ >+ <Brain size={12} />+ {loading ? 'Collaborating...' : '🤝 Team Discussion'}+ </button>+ )}</div></div>@@ -562,10 +841,10 @@ const AgentConfigTab: React.FC = () => {</div></div>- {/* LLM Config */}+ {/* LLM Config - Show ACTIVE from Settings */}<div><div style={{ fontSize: '10px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '6px' }}>- LLM CONFIGURATION+ LLM CONFIGURATION (ACTIVE FROM SETTINGS)</div><div style={{padding: '8px',@@ -576,22 +855,38 @@ const AgentConfigTab: React.FC = () => {gap: '8px',fontSize: '10px'}}>- <div>- <span style={{ color: BLOOMBERG.GRAY }}>Provider:</span>{' '}- <span style={{ color: BLOOMBERG.CYAN }}>{selectedAgent.llm_config.provider}</span>- </div>- <div>- <span style={{ color: BLOOMBERG.GRAY }}>Model:</span>{' '}- <span style={{ color: BLOOMBERG.PURPLE }}>{selectedAgent.llm_config.model_id}</span>- </div>- <div>- <span style={{ color: BLOOMBERG.GRAY }}>Temperature:</span>{' '}- <span style={{ color: BLOOMBERG.YELLOW }}>{selectedAgent.llm_config.temperature}</span>- </div>- <div>- <span style={{ color: BLOOMBERG.GRAY }}>Max Tokens:</span>{' '}- <span style={{ color: BLOOMBERG.YELLOW }}>{selectedAgent.llm_config.max_tokens}</span>- </div>+ {(() => {+ const activeLLM = llmConfigs.find(c => c.is_active);+ if (!activeLLM) {+ return (+ <div style={{ gridColumn: '1 / -1', color: BLOOMBERG.RED, textAlign: 'center' }}>+ ⚠️ No active LLM configured in Settings+ </div>+ );+ }+ return (+ <>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Provider:</span>{' '}+ <span style={{ color: BLOOMBERG.CYAN }}>{activeLLM.provider}</span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Model:</span>{' '}+ <span style={{ color: BLOOMBERG.PURPLE }}>{activeLLM.model}</span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>API Key:</span>{' '}+ <span style={{ color: activeLLM.api_key ? BLOOMBERG.GREEN : BLOOMBERG.RED }}>+ {activeLLM.api_key ? '✓ Configured' : '✗ Missing'}+ </span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Status:</span>{' '}+ <span style={{ color: BLOOMBERG.GREEN }}>● ACTIVE</span>+ </div>+ </>+ );+ })()}</div></div>@@ -724,28 +1019,6 @@ const AgentConfigTab: React.FC = () => {{selectedAgent.instructions}</div></div>-- {/* Test Result */}- {testResult && (- <div>- <div style={{ fontSize: '10px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '6px' }}>- TEST RESULT- </div>- <div style={{- padding: '8px',- backgroundColor: BLOOMBERG.DARK_BG,- border: `1px solid ${testResult.success ? BLOOMBERG.GREEN : BLOOMBERG.RED}`,- fontSize: '10px',- maxHeight: '200px',- overflow: 'auto',- fontFamily: 'monospace'- }}>- <pre style={{ margin: 0, color: testResult.success ? BLOOMBERG.GREEN : BLOOMBERG.RED }}>- {JSON.stringify(testResult, null, 2)}- </pre>- </div>- </div>- )}</div>)}</div>@@ -766,7 +1039,252 @@ const AgentConfigTab: React.FC = () => {</div>)}</div>++ {/* Right Panel - Test Results */}+ {testResult && (+ <div style={{+ width: '400px',+ display: 'flex',+ flexDirection: 'column',+ backgroundColor: BLOOMBERG.PANEL_BG,+ overflow: 'hidden'+ }}>+ {/* Header */}+ <div style={{+ padding: '8px 12px',+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ backgroundColor: BLOOMBERG.HEADER_BG,+ fontSize: '11px',+ fontWeight: 600,+ color: BLOOMBERG.GRAY,+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between'+ }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <Zap size={12} color={testResult.success ? BLOOMBERG.GREEN : BLOOMBERG.RED} />+ <span>TEST RESULT</span>+ </div>+ <button+ onClick={() => setTestResult(null)}+ style={{+ padding: '2px 6px',+ backgroundColor: 'transparent',+ border: `1px solid ${BLOOMBERG.BORDER}`,+ color: BLOOMBERG.GRAY,+ cursor: 'pointer',+ fontSize: '9px'+ }}+ >+ Close+ </button>+ </div>++ {/* Result Content */}+ <div style={{ flex: 1, overflow: 'auto', padding: '12px' }}>+ {/* Status Banner */}+ <div style={{+ padding: '8px',+ backgroundColor: testResult.success ? BLOOMBERG.GREEN + '20' : BLOOMBERG.RED + '20',+ border: `1px solid ${testResult.success ? BLOOMBERG.GREEN : BLOOMBERG.RED}`,+ marginBottom: '12px',+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ fontSize: '10px',+ color: testResult.success ? BLOOMBERG.GREEN : BLOOMBERG.RED+ }}>+ {testResult.success ? <CheckCircle size={14} /> : <AlertCircle size={14} />}+ <span style={{ fontWeight: 600 }}>+ {testResult.success ? 'SUCCESS' : 'FAILED'}+ </span>+ </div>++ {/* Agent Info */}+ {testResult.agent_name && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ AGENT+ </div>+ <div style={{+ padding: '6px 8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ fontSize: '10px',+ color: BLOOMBERG.CYAN+ }}>+ {testResult.agent_name}+ </div>+ </div>+ )}++ {/* Provider & Model */}+ {testResult.provider && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ PROVIDER & MODEL+ </div>+ <div style={{+ padding: '6px 8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ fontSize: '10px',+ display: 'flex',+ gap: '8px'+ }}>+ <span style={{ color: BLOOMBERG.YELLOW }}>{testResult.provider}</span>+ <span style={{ color: BLOOMBERG.GRAY }}>•</span>+ <span style={{ color: BLOOMBERG.PURPLE }}>{testResult.model}</span>+ </div>+ </div>+ )}++ {/* Team Discussion */}+ {testResult.discussion && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ TEAM DISCUSSION ({testResult.total_agents} AGENTS, {testResult.rounds} ROUNDS)+ </div>+ <div style={{ maxHeight: '500px', overflow: 'auto' }}>+ {testResult.discussion.map((entry: any, idx: number) => (+ <div key={idx} style={{+ padding: '8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ marginBottom: '8px',+ fontSize: '10px'+ }}>+ <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '4px' }}>+ <span style={{ color: BLOOMBERG.CYAN, fontWeight: 600 }}>{entry.agent}</span>+ <span style={{ color: BLOOMBERG.GRAY, fontSize: '9px' }}>Round {entry.round}</span>+ </div>+ <div style={{ color: BLOOMBERG.GRAY, fontSize: '9px', marginBottom: '4px' }}>+ {entry.role}+ </div>+ <div style={{ color: BLOOMBERG.WHITE, lineHeight: '1.6' }}>+ <ReactMarkdown+ components={{+ p: ({ node, ...props }) => <p style={{ margin: '0.5em 0' }} {...props} />,+ strong: ({ node, ...props }) => <strong style={{ color: BLOOMBERG.CYAN, fontWeight: 600 }} {...props} />,+ em: ({ node, ...props }) => <em style={{ color: BLOOMBERG.YELLOW }} {...props} />,+ ul: ({ node, ...props }) => <ul style={{ margin: '0.5em 0', paddingLeft: '1.5em' }} {...props} />,+ ol: ({ node, ...props }) => <ol style={{ margin: '0.5em 0', paddingLeft: '1.5em' }} {...props} />,+ li: ({ node, ...props }) => <li style={{ margin: '0.25em 0' }} {...props} />,+ }}+ >+ {entry.response}+ </ReactMarkdown>+ </div>+ </div>+ ))}+ </div>+ </div>+ )}++ {/* Response */}+ {testResult.response && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ RESPONSE+ </div>+ <div style={{+ padding: '8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ fontSize: '10px',+ maxHeight: '300px',+ overflow: 'auto',+ lineHeight: '1.6',+ color: BLOOMBERG.WHITE+ }}>+ <ReactMarkdown+ components={{+ p: ({ node, ...props }) => <p style={{ margin: '0.5em 0' }} {...props} />,+ strong: ({ node, ...props }) => <strong style={{ color: BLOOMBERG.CYAN, fontWeight: 600 }} {...props} />,+ em: ({ node, ...props }) => <em style={{ color: BLOOMBERG.YELLOW }} {...props} />,+ ul: ({ node, ...props }) => <ul style={{ margin: '0.5em 0', paddingLeft: '1.5em' }} {...props} />,+ ol: ({ node, ...props }) => <ol style={{ margin: '0.5em 0', paddingLeft: '1.5em' }} {...props} />,+ li: ({ node, ...props }) => <li style={{ margin: '0.25em 0' }} {...props} />,+ }}+ >+ {testResult.response}+ </ReactMarkdown>+ </div>+ </div>+ )}++ {/* Tokens Used */}+ {testResult.tokens_used && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.GRAY, marginBottom: '4px' }}>+ TOKENS USED+ </div>+ <div style={{+ padding: '6px 8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ fontSize: '10px',+ color: BLOOMBERG.CYAN+ }}>+ {testResult.tokens_used.toLocaleString()}+ </div>+ </div>+ )}++ {/* Error Message */}+ {testResult.error && (+ <div style={{ marginBottom: '12px' }}>+ <div style={{ fontSize: '9px', fontWeight: 600, color: BLOOMBERG.RED, marginBottom: '4px' }}>+ ERROR+ </div>+ <div style={{+ padding: '8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.RED}`,+ fontSize: '10px',+ color: BLOOMBERG.RED,+ lineHeight: '1.6',+ whiteSpace: 'pre-wrap'+ }}>+ {testResult.error}+ </div>+ </div>+ )}++ {/* Raw JSON (collapsed by default) */}+ <details style={{ marginTop: '12px' }}>+ <summary style={{+ fontSize: '9px',+ fontWeight: 600,+ color: BLOOMBERG.GRAY,+ cursor: 'pointer',+ marginBottom: '4px',+ padding: '4px',+ backgroundColor: BLOOMBERG.HEADER_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`+ }}>+ RAW JSON+ </summary>+ <div style={{+ padding: '8px',+ backgroundColor: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace',+ maxHeight: '200px',+ overflow: 'auto',+ marginTop: '4px'+ }}>+ <pre style={{ margin: 0, color: BLOOMBERG.CYAN }}>+ {JSON.stringify(testResult, null, 2)}+ </pre>+ </div>+ </details>+ </div>+ </div>+ )}</div>+</div>);};diff --git a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/AIAgentsPanel.tsx b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/AIAgentsPanel.tsxindex 0969a5637..701ac55ee 100644--- a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/AIAgentsPanel.tsx+++ b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/AIAgentsPanel.tsx@@ -17,10 +17,14 @@ import agnoTradingService, {type AgentInfo,type MarketAnalysis,type TradeSignal,- type RiskAnalysis+ type RiskAnalysis,+ type TradeExecutionResult} from '../../../../services/agnoTradingService';import { AgentConfigurationUI } from './AgentConfigurationUI';import { CompetitionPanel } from './CompetitionPanel';+import { DebateArenaPanel } from './DebateArenaPanel';+import { DecisionFeedPanel } from './DecisionFeedPanel';+import { TradeHistoryPanel } from './TradeHistoryPanel';// Bloomberg color paletteconst BLOOMBERG = {@@ -234,6 +238,54 @@ export function AIAgentsPanel({ selectedSymbol, portfolioData }: AIAgentsPanelPr}};+ const handleExecuteTrade = async () => {+ if (!result || result.type !== 'trade_signal') {+ setError('Generate a trade signal first');+ return;+ }++ if (!portfolioData) {+ setError('Portfolio data not available');+ return;+ }++ setIsLoading(true);+ setError(null);++ try {+ // Extract signal data+ const signalData = result.data;++ // Create portfolio snapshot+ const portfolio = {+ total_value: portfolioData.total_value,+ positions: portfolioData.positions || [],+ daily_pnl: 0+ };++ // Execute trade via trade executor+ const response = await agnoTradingService.executeTrade(+ signalData,+ portfolio,+ 'quick_action_agent',+ selectedModel+ );++ if (response.success && response.data) {+ setResult({+ type: 'trade_execution',+ data: response.data+ });+ } else {+ setError(response.error || 'Trade execution failed');+ }+ } catch (err) {+ setError(err instanceof Error ? err.message : 'Unknown error');+ } finally {+ setIsLoading(false);+ }+ };+// ============================================================================// Render// ============================================================================@@ -369,6 +421,7 @@ export function AIAgentsPanel({ selectedSymbol, portfolioData }: AIAgentsPanelPronGenerateSignal={handleGenerateSignal}onAssessRisk={handleAssessRisk}onStartCompetition={handleStartCompetition}+ onExecuteTrade={handleExecuteTrade}/></div>)}@@ -422,6 +475,7 @@ interface QuickActionsViewProps {onGenerateSignal: () => void;onAssessRisk: () => void;onStartCompetition: () => void;+ onExecuteTrade: () => void;}function QuickActionsView({@@ -440,7 +494,8 @@ function QuickActionsView({onAnalyzeMarket,onGenerateSignal,onAssessRisk,- onStartCompetition+ onStartCompetition,+ onExecuteTrade}: QuickActionsViewProps) {const models = availableModels.length > 0 ? availableModels : [{ value: 'openai:gpt-4o-mini', label: 'GPT-4o Mini (Configure in Settings)' },@@ -695,7 +750,36 @@ function QuickActionsView({{result.type === 'trade_signal' && 'TRADE SIGNAL'}{result.type === 'risk_analysis' && 'RISK ASSESSMENT'}{result.type === 'competition' && 'MULTI-MODEL COMPETITION'}+ {result.type === 'trade_execution' && 'TRADE EXECUTED'}</span>++ {/* Execute Button for Trade Signals */}+ {result.type === 'trade_signal' && (+ <button+ onClick={onExecuteTrade}+ disabled={isLoading}+ style={{+ marginLeft: 'auto',+ background: BLOOMBERG.ORANGE,+ border: `1px solid ${BLOOMBERG.ORANGE}`,+ color: BLOOMBERG.DARK_BG,+ padding: '3px 8px',+ borderRadius: '2px',+ fontSize: '9px',+ fontWeight: '700',+ cursor: isLoading ? 'not-allowed' : 'pointer',+ opacity: isLoading ? 0.5 : 1,+ display: 'flex',+ alignItems: 'center',+ gap: '3px',+ letterSpacing: '0.3px',+ transition: 'all 0.2s'+ }}+ >+ {isLoading ? <Loader2 size={10} className="animate-spin" /> : <Zap size={10} />}+ EXECUTE+ </button>+ )}</div>{result.type === 'competition' ? (@@ -756,6 +840,106 @@ function QuickActionsView({</div></div></div>+ ) : result.type === 'trade_execution' ? (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '6px' }}>+ {/* Trade Success Message */}+ {result.data.success && (+ <div style={{+ background: `${BLOOMBERG.GREEN}15`,+ border: `1px solid ${BLOOMBERG.GREEN}`,+ borderRadius: '2px',+ padding: '6px',+ fontSize: '9px',+ color: BLOOMBERG.GREEN+ }}>+ ✓ Trade executed successfully (Paper Trading)+ {result.data.trade_id && <span style={{ marginLeft: '6px' }}>ID: {result.data.trade_id}</span>}+ </div>+ )}++ {/* Warnings */}+ {result.data.warnings && result.data.warnings.length > 0 && (+ <div style={{+ background: `${BLOOMBERG.YELLOW}15`,+ border: `1px solid ${BLOOMBERG.YELLOW}`,+ borderRadius: '2px',+ padding: '6px'+ }}>+ {result.data.warnings.map((warn: string, idx: number) => (+ <div key={idx} style={{ fontSize: '8px', color: BLOOMBERG.YELLOW, marginBottom: '2px' }}>+ ⚠ {warn}+ </div>+ ))}+ </div>+ )}++ {/* Trade Details */}+ {result.data.trade_data && (+ <div style={{+ background: BLOOMBERG.PANEL_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '2px',+ padding: '6px',+ display: 'grid',+ gridTemplateColumns: '1fr 1fr',+ gap: '4px',+ fontSize: '9px'+ }}>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Symbol:</span>+ <span style={{ color: BLOOMBERG.WHITE, fontWeight: '700', marginLeft: '4px' }}>+ {result.data.trade_data.symbol}+ </span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Side:</span>+ <span style={{+ color: result.data.trade_data.side === 'buy' ? BLOOMBERG.GREEN : BLOOMBERG.RED,+ fontWeight: '700',+ marginLeft: '4px',+ textTransform: 'uppercase'+ }}>+ {result.data.trade_data.side}+ </span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Entry:</span>+ <span style={{ color: BLOOMBERG.CYAN, fontWeight: '700', marginLeft: '4px' }}>+ ${result.data.trade_data.entry_price?.toFixed(2)}+ </span>+ </div>+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Quantity:</span>+ <span style={{ color: BLOOMBERG.WHITE, fontWeight: '700', marginLeft: '4px' }}>+ {result.data.trade_data.quantity}+ </span>+ </div>+ {result.data.trade_data.stop_loss && (+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Stop Loss:</span>+ <span style={{ color: BLOOMBERG.RED, fontWeight: '700', marginLeft: '4px' }}>+ ${result.data.trade_data.stop_loss.toFixed(2)}+ </span>+ </div>+ )}+ {result.data.trade_data.take_profit && (+ <div>+ <span style={{ color: BLOOMBERG.GRAY }}>Take Profit:</span>+ <span style={{ color: BLOOMBERG.GREEN, fontWeight: '700', marginLeft: '4px' }}>+ ${result.data.trade_data.take_profit.toFixed(2)}+ </span>+ </div>+ )}+ </div>+ )}++ {/* Execution Time */}+ {result.data.execution_time_ms && (+ <div style={{ fontSize: '8px', color: BLOOMBERG.GRAY, textAlign: 'right' }}>+ Executed in {result.data.execution_time_ms}ms+ </div>+ )}+ </div>) : (<div style={{color: BLOOMBERG.WHITE,diff --git a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/CompetitionPanel.tsx b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/CompetitionPanel.tsxindex 15339e2c0..956f749ca 100644--- a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/CompetitionPanel.tsx+++ b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/CompetitionPanel.tsx@@ -44,32 +44,75 @@ export function CompetitionPanel({ selectedSymbol }: CompetitionPanelProps) {// Competition setup stateconst [competitionName, setCompetitionName] = useState('AI Trading Competition');- const [selectedModels, setSelectedModels] = useState<string[]>([- 'openai:gpt-4o-mini',- 'anthropic:claude-sonnet-4',- 'google:gemini-2.0-flash'- ]);+ const [selectedModels, setSelectedModels] = useState<string[]>([]);const [taskType, setTaskType] = useState<'analyze' | 'signal' | 'evaluate'>('analyze');const [autoRefresh, setAutoRefresh] = useState(true);+ const [availableModels, setAvailableModels] = useState<Array<{ value: string; label: string; color: string }>>([]);++ // Color mapping for providers+ const getProviderColor = (provider: string) => {+ const colorMap: Record<string, string> = {+ 'openai': BLOOMBERG.GREEN,+ 'anthropic': BLOOMBERG.ORANGE,+ 'google': BLOOMBERG.BLUE,+ 'groq': BLOOMBERG.PURPLE,+ 'deepseek': BLOOMBERG.CYAN,+ 'xai': BLOOMBERG.YELLOW,+ 'together': BLOOMBERG.PURPLE,+ 'mistral': BLOOMBERG.BLUE,+ 'cohere': BLOOMBERG.CYAN+ };+ return colorMap[provider.toLowerCase()] || BLOOMBERG.GRAY;+ };- // Available models- const availableModels = [- { value: 'openai:gpt-4o-mini', label: 'GPT-4o Mini', color: BLOOMBERG.GREEN },- { value: 'openai:gpt-4o', label: 'GPT-4o', color: BLOOMBERG.GREEN },- { value: 'anthropic:claude-sonnet-4', label: 'Claude Sonnet 4', color: BLOOMBERG.ORANGE },- { value: 'anthropic:claude-3-5-sonnet', label: 'Claude 3.5 Sonnet', color: BLOOMBERG.ORANGE },- { value: 'google:gemini-2.0-flash', label: 'Gemini 2.0 Flash', color: BLOOMBERG.BLUE },- { value: 'google:gemini-1.5-pro', label: 'Gemini 1.5 Pro', color: BLOOMBERG.BLUE },- { value: 'groq:llama-3.1-70b', label: 'Llama 3.1 70B', color: BLOOMBERG.PURPLE },- { value: 'groq:mixtral-8x7b', label: 'Mixtral 8x7B', color: BLOOMBERG.PURPLE },- { value: 'deepseek:deepseek-chat', label: 'DeepSeek Chat', color: BLOOMBERG.CYAN },- { value: 'xai:grok-2', label: 'Grok 2', color: BLOOMBERG.YELLOW }- ];+ // Load configured models from database+ useEffect(() => {+ const loadConfiguredModels = async () => {+ try {+ console.log('[CompetitionPanel] Loading configured models...');+ const { sqliteService } = await import('../../../../services/sqliteService');+ const configs = await sqliteService.getLLMConfigs();+ console.log('[CompetitionPanel] Raw configs:', configs);++ // Filter to only models with API keys configured+ const configuredModels = configs+ .filter(c => c.api_key && c.api_key.trim().length > 0)+ .map(c => ({+ value: `${c.provider}:${c.model}`,+ label: `${c.provider.charAt(0).toUpperCase() + c.provider.slice(1)} - ${c.model}`,+ color: getProviderColor(c.provider)+ }));++ console.log('[CompetitionPanel] Configured models:', configuredModels);+ setAvailableModels(configuredModels);++ // Auto-select first 3 models if available+ if (configuredModels.length >= 3) {+ const selected = configuredModels.slice(0, 3).map(m => m.value);+ console.log('[CompetitionPanel] Auto-selecting first 3 models:', selected);+ setSelectedModels(selected);+ } else if (configuredModels.length >= 2) {+ const selected = configuredModels.slice(0, 2).map(m => m.value);+ console.log('[CompetitionPanel] Auto-selecting first 2 models:', selected);+ setSelectedModels(selected);+ } else {+ console.warn('[CompetitionPanel] Not enough models configured for competition (need at least 2)');+ }+ } catch (err) {+ console.error('[CompetitionPanel] Failed to load configured models:', err);+ setError('Failed to load configured models. Please configure API keys in Settings → LLM Config');+ }+ };++ loadConfiguredModels();+ }, []);// Create competitionconst handleCreateCompetition = async () => {if (selectedModels.length < 2) {- setError('Select at least 2 models to compete');+ const errorMsg = 'Select at least 2 models to compete';+ console.error('[CompetitionPanel]', errorMsg);+ setError(errorMsg);return;}@@ -77,20 +120,33 @@ export function CompetitionPanel({ selectedSymbol }: CompetitionPanelProps) {setIsLoading(true);setError(null);+ console.log('[CompetitionPanel] Creating competition:', {+ name: competitionName,+ models: selectedModels,+ type: 'trading'+ });+const response = await agnoTradingService.createCompetition(competitionName,selectedModels,'trading');+ console.log('[CompetitionPanel] Create competition response:', response);+if (response.success && response.data) {+ console.log('[CompetitionPanel] Competition created successfully. Team ID:', response.data.team_id);setTeamId(response.data.team_id);setShowSetup(false);} else {- setError(response.error || 'Failed to create competition');+ const errorMsg = response.error || 'Failed to create competition';+ console.error('[CompetitionPanel] Competition creation failed:', errorMsg);+ setError(errorMsg);}} catch (err) {- setError(err instanceof Error ? err.message : String(err));+ console.error('[CompetitionPanel] Exception during competition creation:', err);+ const errorMsg = err instanceof Error ? err.message : String(err);+ setError(errorMsg);} finally {setIsLoading(false);}@@ -98,26 +154,48 @@ export function CompetitionPanel({ selectedSymbol }: CompetitionPanelProps) {// Run competitionconst handleRunCompetition = async () => {- if (!teamId) return;+ if (!teamId) {+ console.error('[CompetitionPanel] No team ID available');+ return;+ }try {setIsLoading(true);setIsRunning(true);setError(null);+ console.log('[CompetitionPanel] Running competition:', {+ teamId,+ symbol: selectedSymbol,+ taskType+ });+const response = await agnoTradingService.runCompetition(teamId,selectedSymbol,taskType);+ console.log('[CompetitionPanel] Run competition response:', response);+if (response.success && response.data) {+ console.log('[CompetitionPanel] Competition completed successfully');setResult(response.data);} else {- setError(response.error || 'Competition failed');+ const errorMsg = response.error || 'Competition failed';+ console.error('[CompetitionPanel] Competition run failed:', errorMsg);+ console.error('[CompetitionPanel] Full response:', JSON.stringify(response, null, 2));+ setError(errorMsg);}} catch (err) {- setError(err instanceof Error ? err.message : String(err));+ console.error('[CompetitionPanel] Exception during competition run:', err);+ console.error('[CompetitionPanel] Error details:', {+ message: err instanceof Error ? err.message : String(err),+ stack: err instanceof Error ? err.stack : undefined,+ raw: err+ });+ const errorMsg = err instanceof Error ? err.message : String(err);+ setError(errorMsg);} finally {setIsLoading(false);setIsRunning(false);@@ -160,11 +238,20 @@ export function CompetitionPanel({ selectedSymbol }: CompetitionPanelProps) {// Toggle model selectionconst toggleModel = (model: string) => {- setSelectedModels(prev =>- prev.includes(model)+ setSelectedModels(prev => {+ const newSelection = prev.includes(model)? prev.filter(m => m !== model)- : [...prev, model]- );+ : [...prev, model];++ console.log('[CompetitionPanel] Model selection updated:', {+ toggled: model,+ wasPreviouslySelected: prev.includes(model),+ previousSelection: prev,+ newSelection: newSelection+ });++ return newSelection;+ });};return (@@ -393,30 +480,89 @@ function SetupView({{/* Model Selection */}<div><label style={{ color: BLOOMBERG.GRAY, fontSize: '9px', display: 'block', marginBottom: '6px' }}>- SELECT MODELS (min 2)+ SELECT MODELS (min 2) - {availableModels.length} Available</label>- <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '4px' }}>- {availableModels.map((model: any) => (- <button- key={model.value}- onClick={() => toggleModel(model.value)}- style={{- background: selectedModels.includes(model.value) ? `${model.color}20` : BLOOMBERG.DARK_BG,- border: `1px solid ${selectedModels.includes(model.value) ? model.color : BLOOMBERG.BORDER}`,- color: selectedModels.includes(model.value) ? model.color : BLOOMBERG.GRAY,- padding: '6px',- borderRadius: '2px',- fontSize: '9px',- fontWeight: selectedModels.includes(model.value) ? '700' : '400',- cursor: 'pointer',- transition: 'all 0.2s',- textAlign: 'left'- }}- >- {model.label}- </button>- ))}- </div>++ {availableModels.length === 0 ? (+ <div style={{+ background: `${BLOOMBERG.YELLOW}15`,+ border: `1px solid ${BLOOMBERG.YELLOW}`,+ borderRadius: '2px',+ padding: '8px',+ fontSize: '9px',+ color: BLOOMBERG.YELLOW,+ textAlign: 'center'+ }}>+ No models configured. Go to Settings → LLM Config to add API keys.+ </div>+ ) : availableModels.length < 2 ? (+ <div style={{+ background: `${BLOOMBERG.ORANGE}15`,+ border: `1px solid ${BLOOMBERG.ORANGE}`,+ borderRadius: '2px',+ padding: '8px',+ fontSize: '9px',+ color: BLOOMBERG.ORANGE,+ textAlign: 'center'+ }}>+ Need at least 2 models for competition. Configure more in Settings → LLM Config.+ </div>+ ) : (+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '4px' }}>+ {availableModels.map((model: any) => {+ const isSelected = selectedModels.includes(model.value);+ return (+ <button+ key={model.value}+ onClick={() => {+ console.log('[CompetitionPanel] Toggle model:', model.value, 'Currently selected:', isSelected);+ toggleModel(model.value);+ }}+ style={{+ background: isSelected ? `${model.color}30` : BLOOMBERG.DARK_BG,+ border: `2px solid ${isSelected ? model.color : BLOOMBERG.BORDER}`,+ color: isSelected ? model.color : BLOOMBERG.GRAY,+ padding: '8px 10px',+ borderRadius: '3px',+ fontSize: '9px',+ fontWeight: isSelected ? '700' : '500',+ cursor: 'pointer',+ transition: 'all 0.2s',+ textAlign: 'left',+ position: 'relative',+ display: 'flex',+ alignItems: 'center',+ gap: '6px'+ }}+ onMouseEnter={(e) => {+ if (!isSelected) {+ e.currentTarget.style.background = BLOOMBERG.HOVER;+ e.currentTarget.style.borderColor = model.color + '50';+ }+ }}+ onMouseLeave={(e) => {+ if (!isSelected) {+ e.currentTarget.style.background = BLOOMBERG.DARK_BG;+ e.currentTarget.style.borderColor = BLOOMBERG.BORDER;+ }+ }}+ >+ {/* Selection Indicator */}+ <div style={{+ width: '10px',+ height: '10px',+ borderRadius: '50%',+ border: `2px solid ${isSelected ? model.color : BLOOMBERG.BORDER}`,+ background: isSelected ? model.color : 'transparent',+ flexShrink: 0,+ transition: 'all 0.2s'+ }} />+ <span>{model.label}</span>+ </button>+ );+ })}+ </div>+ )}</div>{/* Task Type */}diff --git a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DebateArenaPanel.tsx b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DebateArenaPanel.tsxnew file mode 100644index 000000000..2b976eb19--- /dev/null+++ b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DebateArenaPanel.tsx@@ -0,0 +1,632 @@+/**+ * Debate Arena Panel+ * Bull vs Bear vs Analyst - Multi-agent trading debate system+ */++import React, { useState, useEffect } from 'react';+import { MessageSquare, TrendingUp, TrendingDown, Brain, Loader2, AlertCircle, CheckCircle, Zap, Play } from 'lucide-react';+import agnoTradingService, { type DebateResult } from '../../../../services/agnoTradingService';++const BLOOMBERG = {+ ORANGE: '#FF8800',+ WHITE: '#FFFFFF',+ RED: '#FF3B3B',+ GREEN: '#00D66F',+ GRAY: '#787878',+ DARK_BG: '#000000',+ PANEL_BG: '#0F0F0F',+ HEADER_BG: '#1A1A1A',+ CYAN: '#00E5FF',+ YELLOW: '#FFD700',+ BLUE: '#0088FF',+ PURPLE: '#9D4EDD',+ BORDER: '#2A2A2A',+ HOVER: '#1F1F1F',+ MUTED: '#4A4A4A'+};++interface DebateArenaPanelProps {+ selectedSymbol: string;+ currentPrice?: number;+ marketData?: any;+}++export function DebateArenaPanel({ selectedSymbol, currentPrice, marketData }: DebateArenaPanelProps) {+ const [bullModel, setBullModel] = useState('openai:gpt-4o-mini');+ const [bearModel, setBearModel] = useState('anthropic:claude-sonnet-4');+ const [analystModel, setAnalystModel] = useState('google:gemini-2.0-flash-exp');+ const [isDebating, setIsDebating] = useState(false);+ const [error, setError] = useState<string | null>(null);+ const [debateResult, setDebateResult] = useState<DebateResult | null>(null);+ const [recentDebates, setRecentDebates] = useState<any[]>([]);+ const [availableModels, setAvailableModels] = useState<Array<{ value: string; label: string; color: string }>>([]);++ // Load available models on mount+ useEffect(() => {+ loadAvailableModels();+ loadRecentDebates();+ }, []);++ const loadAvailableModels = async () => {+ try {+ const { sqliteService } = await import('../../../../services/sqliteService');+ const configs = await sqliteService.getLLMConfigs();++ const configured = configs.filter(c => c.api_key && c.api_key.trim().length > 0);++ const models = configured.map(c => ({+ value: `${c.provider}:${c.model}`,+ label: `${c.provider.charAt(0).toUpperCase() + c.provider.slice(1)} - ${c.model}`,+ color: getModelColor(c.provider)+ }));++ setAvailableModels(models);++ // Auto-select first 3 if available+ if (models.length >= 3) {+ setBullModel(models[0].value);+ setBearModel(models[1].value);+ setAnalystModel(models[2].value);+ }+ } catch (err) {+ console.error('Failed to load models:', err);+ }+ };++ const loadRecentDebates = async () => {+ try {+ const response = await agnoTradingService.getRecentDebates(5);+ if (response.success && response.data) {+ setRecentDebates(response.data.debates || []);+ }+ } catch (err) {+ console.error('Failed to load debates:', err);+ }+ };++ const getModelColor = (provider: string) => {+ const colors: Record<string, string> = {+ openai: BLOOMBERG.GREEN,+ anthropic: BLOOMBERG.ORANGE,+ google: BLOOMBERG.BLUE,+ gemini: BLOOMBERG.BLUE,+ groq: BLOOMBERG.PURPLE,+ deepseek: BLOOMBERG.CYAN,+ xai: BLOOMBERG.YELLOW+ };+ return colors[provider.toLowerCase()] || BLOOMBERG.GRAY;+ };++ const handleStartDebate = async () => {+ if (!selectedSymbol) {+ setError('No symbol selected');+ return;+ }++ if (bullModel === bearModel || bearModel === analystModel || bullModel === analystModel) {+ setError('Please select different models for each role');+ return;+ }++ setIsDebating(true);+ setError(null);+ setDebateResult(null);++ try {+ const market = {+ price: currentPrice || 0,+ symbol: selectedSymbol,+ ...marketData+ };++ const response = await agnoTradingService.runDebate(+ selectedSymbol,+ market,+ bullModel,+ bearModel,+ analystModel+ );++ if (response.success && response.data) {+ setDebateResult(response.data);+ await loadRecentDebates(); // Refresh history+ } else {+ setError(response.error || 'Debate failed');+ }+ } catch (err) {+ setError(err instanceof Error ? err.message : String(err));+ } finally {+ setIsDebating(false);+ }+ };++ const canStartDebate = availableModels.length >= 3 && !isDebating;++ return (+ <div style={{+ height: '100%',+ background: BLOOMBERG.PANEL_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '4px',+ display: 'flex',+ flexDirection: 'column',+ overflow: 'hidden'+ }}>+ {/* Header */}+ <div style={{+ background: BLOOMBERG.HEADER_BG,+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ padding: '8px 10px',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between'+ }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <MessageSquare size={14} color={BLOOMBERG.ORANGE} />+ <span style={{+ color: BLOOMBERG.WHITE,+ fontSize: '11px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ DEBATE ARENA+ </span>+ {isDebating && (+ <Loader2 size={12} color={BLOOMBERG.ORANGE} className="animate-spin" />+ )}+ </div>+ <span style={{ color: BLOOMBERG.GRAY, fontSize: '9px', fontFamily: '"IBM Plex Mono", monospace' }}>+ {selectedSymbol}+ </span>+ </div>++ {/* Content */}+ <div style={{ flex: 1, overflow: 'auto', padding: '10px', display: 'flex', flexDirection: 'column', gap: '10px' }}>++ {/* Model Selection */}+ {!debateResult && (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>+ {/* Bull Model */}+ <div>+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ marginBottom: '4px'+ }}>+ <TrendingUp size={10} color={BLOOMBERG.GREEN} />+ <label style={{+ color: BLOOMBERG.GREEN,+ fontSize: '9px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ BULL AGENT+ </label>+ </div>+ <select+ value={bullModel}+ onChange={(e) => setBullModel(e.target.value)}+ disabled={isDebating || availableModels.length === 0}+ style={{+ width: '100%',+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.GREEN}`,+ color: BLOOMBERG.WHITE,+ padding: '5px 8px',+ borderRadius: '2px',+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace',+ cursor: 'pointer'+ }}+ >+ {availableModels.map(m => (+ <option key={m.value} value={m.value}>{m.label}</option>+ ))}+ </select>+ </div>++ {/* Bear Model */}+ <div>+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ marginBottom: '4px'+ }}>+ <TrendingDown size={10} color={BLOOMBERG.RED} />+ <label style={{+ color: BLOOMBERG.RED,+ fontSize: '9px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ BEAR AGENT+ </label>+ </div>+ <select+ value={bearModel}+ onChange={(e) => setBearModel(e.target.value)}+ disabled={isDebating || availableModels.length === 0}+ style={{+ width: '100%',+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.RED}`,+ color: BLOOMBERG.WHITE,+ padding: '5px 8px',+ borderRadius: '2px',+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace',+ cursor: 'pointer'+ }}+ >+ {availableModels.map(m => (+ <option key={m.value} value={m.value}>{m.label}</option>+ ))}+ </select>+ </div>++ {/* Analyst Model */}+ <div>+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ marginBottom: '4px'+ }}>+ <Brain size={10} color={BLOOMBERG.ORANGE} />+ <label style={{+ color: BLOOMBERG.ORANGE,+ fontSize: '9px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ ANALYST AGENT+ </label>+ </div>+ <select+ value={analystModel}+ onChange={(e) => setAnalystModel(e.target.value)}+ disabled={isDebating || availableModels.length === 0}+ style={{+ width: '100%',+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.ORANGE}`,+ color: BLOOMBERG.WHITE,+ padding: '5px 8px',+ borderRadius: '2px',+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace',+ cursor: 'pointer'+ }}+ >+ {availableModels.map(m => (+ <option key={m.value} value={m.value}>{m.label}</option>+ ))}+ </select>+ </div>++ {/* Start Button */}+ <button+ onClick={handleStartDebate}+ disabled={!canStartDebate}+ style={{+ width: '100%',+ background: canStartDebate ? BLOOMBERG.ORANGE : BLOOMBERG.GRAY,+ border: 'none',+ color: canStartDebate ? BLOOMBERG.DARK_BG : BLOOMBERG.MUTED,+ padding: '10px',+ borderRadius: '2px',+ fontSize: '10px',+ fontWeight: '700',+ cursor: canStartDebate ? 'pointer' : 'not-allowed',+ opacity: canStartDebate ? 1 : 0.5,+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'center',+ gap: '6px',+ letterSpacing: '0.5px',+ marginTop: '4px'+ }}+ >+ {isDebating ? (+ <>+ <Loader2 size={14} className="animate-spin" />+ DEBATING...+ </>+ ) : (+ <>+ <Play size={14} />+ START DEBATE+ </>+ )}+ </button>++ {availableModels.length < 3 && (+ <div style={{+ background: `${BLOOMBERG.YELLOW}15`,+ border: `1px solid ${BLOOMBERG.YELLOW}`,+ borderRadius: '2px',+ padding: '6px 8px',+ fontSize: '8px',+ color: BLOOMBERG.YELLOW+ }}>+ Configure at least 3 models in Settings → LLM Config+ </div>+ )}+ </div>+ )}++ {/* Error Display */}+ {error && (+ <div style={{+ background: `${BLOOMBERG.RED}15`,+ border: `1px solid ${BLOOMBERG.RED}`,+ borderRadius: '2px',+ padding: '8px',+ display: 'flex',+ alignItems: 'flex-start',+ gap: '6px'+ }}>+ <AlertCircle size={12} color={BLOOMBERG.RED} style={{ flexShrink: 0, marginTop: '1px' }} />+ <div>+ <div style={{ color: BLOOMBERG.RED, fontSize: '9px', fontWeight: '600' }}>ERROR</div>+ <div style={{ color: BLOOMBERG.GRAY, fontSize: '8px', marginTop: '2px' }}>{error}</div>+ </div>+ </div>+ )}++ {/* Debate Result */}+ {debateResult && (+ <div style={{ display: 'flex', flexDirection: 'column', gap: '10px' }}>+ {/* Final Decision Card */}+ <div style={{+ background: BLOOMBERG.DARK_BG,+ border: `2px solid ${BLOOMBERG.ORANGE}`,+ borderRadius: '4px',+ padding: '10px'+ }}>+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '6px',+ marginBottom: '8px'+ }}>+ <CheckCircle size={14} color={BLOOMBERG.ORANGE} />+ <span style={{ color: BLOOMBERG.ORANGE, fontSize: '10px', fontWeight: '700', letterSpacing: '0.5px' }}>+ FINAL DECISION+ </span>+ </div>++ <div style={{+ background: BLOOMBERG.PANEL_BG,+ borderRadius: '2px',+ padding: '8px',+ marginBottom: '8px'+ }}>+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px', marginBottom: '8px' }}>+ <div>+ <div style={{ color: BLOOMBERG.GRAY, fontSize: '7px', marginBottom: '3px' }}>ACTION</div>+ <div style={{+ color: debateResult.final_action === 'BUY' ? BLOOMBERG.GREEN :+ debateResult.final_action === 'SELL' ? BLOOMBERG.RED : BLOOMBERG.YELLOW,+ fontSize: '14px',+ fontWeight: '700',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {debateResult.final_action}+ </div>+ </div>+ <div>+ <div style={{ color: BLOOMBERG.GRAY, fontSize: '7px', marginBottom: '3px' }}>CONFIDENCE</div>+ <div style={{+ color: BLOOMBERG.CYAN,+ fontSize: '14px',+ fontWeight: '700',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {debateResult.confidence}%+ </div>+ </div>+ </div>++ {debateResult.entry_price && (+ <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '6px', fontSize: '8px' }}>+ <div>+ <div style={{ color: BLOOMBERG.GRAY, marginBottom: '2px' }}>ENTRY</div>+ <div style={{ color: BLOOMBERG.WHITE, fontWeight: '600', fontFamily: '"IBM Plex Mono", monospace' }}>+ ${debateResult.entry_price.toFixed(2)}+ </div>+ </div>+ {debateResult.stop_loss && (+ <div>+ <div style={{ color: BLOOMBERG.GRAY, marginBottom: '2px' }}>STOP</div>+ <div style={{ color: BLOOMBERG.RED, fontWeight: '600', fontFamily: '"IBM Plex Mono", monospace' }}>+ ${debateResult.stop_loss.toFixed(2)}+ </div>+ </div>+ )}+ {debateResult.take_profit && (+ <div>+ <div style={{ color: BLOOMBERG.GRAY, marginBottom: '2px' }}>TARGET</div>+ <div style={{ color: BLOOMBERG.GREEN, fontWeight: '600', fontFamily: '"IBM Plex Mono", monospace' }}>+ ${debateResult.take_profit.toFixed(2)}+ </div>+ </div>+ )}+ </div>+ )}+ </div>++ <button+ onClick={() => setDebateResult(null)}+ style={{+ width: '100%',+ background: 'transparent',+ border: `1px solid ${BLOOMBERG.BORDER}`,+ color: BLOOMBERG.GRAY,+ padding: '6px',+ borderRadius: '2px',+ fontSize: '9px',+ fontWeight: '600',+ cursor: 'pointer',+ letterSpacing: '0.3px'+ }}+ >+ NEW DEBATE+ </button>+ </div>++ {/* Arguments */}+ <div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>+ {/* Bull Argument */}+ <DebateArgumentCard+ role="BULL"+ model={bullModel}+ argument={debateResult.bull_argument}+ color={BLOOMBERG.GREEN}+ />++ {/* Bear Argument */}+ <DebateArgumentCard+ role="BEAR"+ model={bearModel}+ argument={debateResult.bear_argument}+ color={BLOOMBERG.RED}+ />++ {/* Analyst Decision */}+ <DebateArgumentCard+ role="ANALYST"+ model={analystModel}+ argument={debateResult.analyst_decision}+ color={BLOOMBERG.ORANGE}+ />+ </div>++ {/* Execution Time */}+ <div style={{+ textAlign: 'center',+ color: BLOOMBERG.MUTED,+ fontSize: '8px',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ Execution time: {(debateResult.execution_time_ms / 1000).toFixed(1)}s+ </div>+ </div>+ )}++ {/* Recent Debates */}+ {!debateResult && recentDebates.length > 0 && (+ <div style={{ marginTop: '10px' }}>+ <div style={{+ color: BLOOMBERG.GRAY,+ fontSize: '9px',+ fontWeight: '600',+ marginBottom: '6px',+ letterSpacing: '0.5px'+ }}>+ RECENT DEBATES+ </div>+ <div style={{ display: 'flex', flexDirection: 'column', gap: '4px' }}>+ {recentDebates.slice(0, 5).map((debate, idx) => (+ <div+ key={idx}+ style={{+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '2px',+ padding: '6px 8px',+ fontSize: '8px',+ display: 'flex',+ justifyContent: 'space-between',+ alignItems: 'center'+ }}+ >+ <span style={{ color: BLOOMBERG.WHITE, fontFamily: '"IBM Plex Mono", monospace' }}>+ {debate.symbol}+ </span>+ <span style={{+ color: debate.final_action === 'BUY' ? BLOOMBERG.GREEN :+ debate.final_action === 'SELL' ? BLOOMBERG.RED : BLOOMBERG.YELLOW,+ fontWeight: '700'+ }}>+ {debate.final_action}+ </span>+ <span style={{ color: BLOOMBERG.GRAY }}>+ {new Date(debate.timestamp * 1000).toLocaleTimeString()}+ </span>+ </div>+ ))}+ </div>+ </div>+ )}+ </div>+ </div>+ );+}++// ============================================================================+// Debate Argument Card Component+// ============================================================================++interface DebateArgumentCardProps {+ role: string;+ model: string;+ argument: string;+ color: string;+}++function DebateArgumentCard({ role, model, argument, color }: DebateArgumentCardProps) {+ const [isExpanded, setIsExpanded] = useState(false);++ return (+ <div style={{+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${color}`,+ borderRadius: '2px',+ overflow: 'hidden'+ }}>+ <div+ onClick={() => setIsExpanded(!isExpanded)}+ style={{+ padding: '6px 8px',+ background: `${color}10`,+ borderBottom: isExpanded ? `1px solid ${BLOOMBERG.BORDER}` : 'none',+ cursor: 'pointer',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between'+ }}+ >+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ {role === 'BULL' && <TrendingUp size={10} color={color} />}+ {role === 'BEAR' && <TrendingDown size={10} color={color} />}+ {role === 'ANALYST' && <Brain size={10} color={color} />}+ <span style={{ color, fontSize: '9px', fontWeight: '700', letterSpacing: '0.3px' }}>+ {role}+ </span>+ </div>+ <span style={{ color: BLOOMBERG.GRAY, fontSize: '8px', fontFamily: '"IBM Plex Mono", monospace' }}>+ {model.split(':')[1] || model}+ </span>+ </div>+ {isExpanded && (+ <div style={{+ padding: '8px',+ color: BLOOMBERG.WHITE,+ fontSize: '9px',+ lineHeight: '1.5',+ maxHeight: '200px',+ overflow: 'auto',+ whiteSpace: 'pre-wrap',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {argument.substring(0, 500)}{argument.length > 500 ? '...' : ''}+ </div>+ )}+ </div>+ );+}++export default DebateArenaPanel;diff --git a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DecisionFeedPanel.tsx b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DecisionFeedPanel.tsxnew file mode 100644index 000000000..457cbaf88--- /dev/null+++ b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/DecisionFeedPanel.tsx@@ -0,0 +1,378 @@+/**+ * Decision Feed Panel+ * Real-time feed of all agent decisions+ */++import React, { useState, useEffect } from 'react';+import { Activity, Brain, Target, Shield, TrendingUp, Filter, RefreshCw } from 'lucide-react';+import agnoTradingService, { type Decision } from '../../../../services/agnoTradingService';++const BLOOMBERG = {+ ORANGE: '#FF8800',+ WHITE: '#FFFFFF',+ RED: '#FF3B3B',+ GREEN: '#00D66F',+ GRAY: '#787878',+ DARK_BG: '#000000',+ PANEL_BG: '#0F0F0F',+ HEADER_BG: '#1A1A1A',+ CYAN: '#00E5FF',+ YELLOW: '#FFD700',+ BLUE: '#0088FF',+ PURPLE: '#9D4EDD',+ BORDER: '#2A2A2A',+ HOVER: '#1F1F1F',+ MUTED: '#4A4A4A'+};++interface DecisionFeedPanelProps {+ agentId?: string;+ autoRefresh?: boolean;+ refreshInterval?: number;+}++export function DecisionFeedPanel({+ agentId,+ autoRefresh = true,+ refreshInterval = 5000+}: DecisionFeedPanelProps) {+ const [decisions, setDecisions] = useState<Decision[]>([]);+ const [isLoading, setIsLoading] = useState(false);+ const [filterType, setFilterType] = useState<string>('all');+ const [error, setError] = useState<string | null>(null);++ useEffect(() => {+ fetchDecisions();++ if (autoRefresh) {+ const interval = setInterval(fetchDecisions, refreshInterval);+ return () => clearInterval(interval);+ }+ }, [agentId, filterType, autoRefresh, refreshInterval]);++ const fetchDecisions = async () => {+ try {+ setIsLoading(true);+ setError(null);++ const response = await agnoTradingService.getDbDecisions(50, agentId);++ if (response.success && response.data) {+ let filtered = response.data.decisions || [];++ // Apply filter+ if (filterType !== 'all') {+ filtered = filtered.filter(d => d.decision_type === filterType);+ }++ setDecisions(filtered);+ } else {+ setError(response.error || 'Failed to load decisions');+ }+ } catch (err) {+ console.error('Failed to fetch decisions:', err);+ setError(err instanceof Error ? err.message : String(err));+ } finally {+ setIsLoading(false);+ }+ };++ const getDecisionTypeColor = (type: string) => {+ const colors: Record<string, string> = {+ analysis: BLOOMBERG.BLUE,+ signal: BLOOMBERG.GREEN,+ trade: BLOOMBERG.ORANGE,+ risk: BLOOMBERG.RED+ };+ return colors[type] || BLOOMBERG.GRAY;+ };++ const getDecisionTypeIcon = (type: string) => {+ const icons: Record<string, any> = {+ analysis: Brain,+ signal: Target,+ trade: TrendingUp,+ risk: Shield+ };+ const Icon = icons[type] || Activity;+ return <Icon size={10} />;+ };++ return (+ <div style={{+ height: '100%',+ background: BLOOMBERG.PANEL_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '4px',+ display: 'flex',+ flexDirection: 'column',+ overflow: 'hidden'+ }}>+ {/* Header */}+ <div style={{+ background: BLOOMBERG.HEADER_BG,+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ padding: '8px 10px',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between'+ }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <Activity size={14} color={BLOOMBERG.CYAN} />+ <span style={{+ color: BLOOMBERG.WHITE,+ fontSize: '11px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ DECISION FEED+ </span>+ {isLoading && (+ <RefreshCw size={10} color={BLOOMBERG.ORANGE} className="animate-spin" />+ )}+ </div>++ <div style={{ display: 'flex', gap: '4px' }}>+ {/* Filter Buttons */}+ {['all', 'analysis', 'signal', 'trade', 'risk'].map(type => (+ <button+ key={type}+ onClick={() => setFilterType(type)}+ style={{+ background: filterType === type ? BLOOMBERG.ORANGE : 'transparent',+ border: `1px solid ${filterType === type ? BLOOMBERG.ORANGE : BLOOMBERG.BORDER}`,+ color: filterType === type ? BLOOMBERG.DARK_BG : BLOOMBERG.GRAY,+ padding: '2px 6px',+ borderRadius: '2px',+ fontSize: '8px',+ fontWeight: '700',+ cursor: 'pointer',+ transition: 'all 0.2s',+ textTransform: 'uppercase',+ letterSpacing: '0.3px'+ }}+ >+ {type}+ </button>+ ))}+ </div>+ </div>++ {/* Content */}+ <div style={{+ flex: 1,+ overflow: 'auto',+ padding: '8px'+ }}>+ {error && (+ <div style={{+ background: `${BLOOMBERG.RED}15`,+ border: `1px solid ${BLOOMBERG.RED}`,+ borderRadius: '2px',+ padding: '8px',+ marginBottom: '8px',+ color: BLOOMBERG.RED,+ fontSize: '9px'+ }}>+ {error}+ </div>+ )}++ {decisions.length === 0 && !isLoading && (+ <div style={{+ textAlign: 'center',+ color: BLOOMBERG.GRAY,+ fontSize: '10px',+ marginTop: '40px'+ }}>+ {filterType === 'all' ? 'No decisions yet' : `No ${filterType} decisions`}+ </div>+ )}++ <div style={{ display: 'flex', flexDirection: 'column', gap: '6px' }}>+ {decisions.map((decision, idx) => (+ <DecisionCard key={decision.id || idx} decision={decision} />+ ))}+ </div>+ </div>+ </div>+ );+}++// ============================================================================+// Decision Card Component+// ============================================================================++interface DecisionCardProps {+ decision: Decision;+}++function DecisionCard({ decision }: DecisionCardProps) {+ const [isExpanded, setIsExpanded] = useState(false);++ const getDecisionTypeColor = (type: string) => {+ const colors: Record<string, string> = {+ analysis: BLOOMBERG.BLUE,+ signal: BLOOMBERG.GREEN,+ trade: BLOOMBERG.ORANGE,+ risk: BLOOMBERG.RED+ };+ return colors[type] || BLOOMBERG.GRAY;+ };++ const getDecisionTypeIcon = (type: string) => {+ const icons: Record<string, any> = {+ analysis: Brain,+ signal: Target,+ trade: TrendingUp,+ risk: Shield+ };+ const Icon = icons[type] || Activity;+ return <Icon size={10} />;+ };++ const typeColor = getDecisionTypeColor(decision.decision_type);+ const TypeIcon = getDecisionTypeIcon(decision.decision_type);++ return (+ <div+ onClick={() => setIsExpanded(!isExpanded)}+ style={{+ background: BLOOMBERG.DARK_BG,+ border: `1px solid ${typeColor}30`,+ borderLeft: `3px solid ${typeColor}`,+ borderRadius: '2px',+ padding: '8px',+ cursor: 'pointer',+ transition: 'all 0.2s'+ }}+ onMouseEnter={(e) => {+ e.currentTarget.style.background = BLOOMBERG.HOVER;+ }}+ onMouseLeave={(e) => {+ e.currentTarget.style.background = BLOOMBERG.DARK_BG;+ }}+ >+ {/* Header */}+ <div style={{+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between',+ marginBottom: isExpanded ? '8px' : '0'+ }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <div style={{ color: typeColor }}>+ {TypeIcon}+ </div>+ <span style={{+ color: typeColor,+ fontSize: '9px',+ fontWeight: '700',+ textTransform: 'uppercase',+ letterSpacing: '0.3px'+ }}>+ {decision.decision_type}+ </span>+ {decision.symbol && (+ <span style={{+ color: BLOOMBERG.WHITE,+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace',+ fontWeight: '600'+ }}>+ {decision.symbol}+ </span>+ )}+ </div>++ <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>+ {decision.confidence !== undefined && (+ <span style={{+ color: BLOOMBERG.CYAN,+ fontSize: '8px',+ fontWeight: '700',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {decision.confidence}%+ </span>+ )}+ <span style={{+ color: BLOOMBERG.GRAY,+ fontSize: '8px',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {new Date(decision.timestamp * 1000).toLocaleTimeString()}+ </span>+ </div>+ </div>++ {/* Decision Text */}+ <div style={{+ color: BLOOMBERG.WHITE,+ fontSize: '9px',+ lineHeight: '1.4',+ fontFamily: '"IBM Plex Mono", monospace',+ marginBottom: isExpanded && decision.reasoning ? '6px' : '0'+ }}>+ {isExpanded ? decision.decision : decision.decision.substring(0, 60) + (decision.decision.length > 60 ? '...' : '')}+ </div>++ {/* Reasoning (when expanded) */}+ {isExpanded && decision.reasoning && (+ <div style={{+ background: BLOOMBERG.PANEL_BG,+ borderRadius: '2px',+ padding: '6px',+ marginTop: '6px'+ }}>+ <div style={{+ color: BLOOMBERG.GRAY,+ fontSize: '7px',+ fontWeight: '700',+ marginBottom: '4px',+ letterSpacing: '0.5px'+ }}>+ REASONING+ </div>+ <div style={{+ color: BLOOMBERG.GRAY,+ fontSize: '8px',+ lineHeight: '1.4',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {decision.reasoning.substring(0, 200)}{decision.reasoning.length > 200 ? '...' : ''}+ </div>+ </div>+ )}++ {/* Footer */}+ <div style={{+ display: 'flex',+ justifyContent: 'space-between',+ alignItems: 'center',+ marginTop: '6px',+ paddingTop: '6px',+ borderTop: `1px solid ${BLOOMBERG.BORDER}`+ }}>+ <span style={{+ color: BLOOMBERG.MUTED,+ fontSize: '8px',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {decision.model.split(':')[1] || decision.model}+ </span>+ {decision.execution_time_ms !== undefined && (+ <span style={{+ color: BLOOMBERG.MUTED,+ fontSize: '7px',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {decision.execution_time_ms}ms+ </span>+ )}+ </div>+ </div>+ );+}++export default DecisionFeedPanel;diff --git a/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/TradeHistoryPanel.tsx b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/TradeHistoryPanel.tsxnew file mode 100644index 000000000..80b151b0e--- /dev/null+++ b/fincept-terminal-desktop/src/components/tabs/trading/ai-agents/TradeHistoryPanel.tsx@@ -0,0 +1,549 @@+/**+ * Trade History Panel+ * Display agent trade history and performance metrics+ */++import React, { useState, useEffect } from 'react';+import { TrendingUp, TrendingDown, Activity, BarChart3, RefreshCw, Filter, ArrowUpDown } from 'lucide-react';+import agnoTradingService, { type AgentTrade, type AgentPerformance } from '../../../../services/agnoTradingService';++const BLOOMBERG = {+ ORANGE: '#FF8800',+ WHITE: '#FFFFFF',+ RED: '#FF3B3B',+ GREEN: '#00D66F',+ GRAY: '#787878',+ DARK_BG: '#000000',+ PANEL_BG: '#0F0F0F',+ HEADER_BG: '#1A1A1A',+ CYAN: '#00E5FF',+ YELLOW: '#FFD700',+ BLUE: '#0088FF',+ PURPLE: '#9D4EDD',+ BORDER: '#2A2A2A',+ HOVER: '#1F1F1F',+ MUTED: '#4A4A4A'+};++interface TradeHistoryPanelProps {+ agentId?: string;+ autoRefresh?: boolean;+ refreshInterval?: number;+}++type SortField = 'date' | 'symbol' | 'pnl' | 'pnl_percent';+type SortDirection = 'asc' | 'desc';++export function TradeHistoryPanel({+ agentId,+ autoRefresh = true,+ refreshInterval = 10000+}: TradeHistoryPanelProps) {+ const [trades, setTrades] = useState<AgentTrade[]>([]);+ const [performance, setPerformance] = useState<AgentPerformance | null>(null);+ const [isLoading, setIsLoading] = useState(false);+ const [filterStatus, setFilterStatus] = useState<string>('all');+ const [sortField, setSortField] = useState<SortField>('date');+ const [sortDirection, setSortDirection] = useState<SortDirection>('desc');+ const [error, setError] = useState<string | null>(null);++ useEffect(() => {+ fetchData();++ if (autoRefresh) {+ const interval = setInterval(fetchData, refreshInterval);+ return () => clearInterval(interval);+ }+ }, [agentId, filterStatus, autoRefresh, refreshInterval]);++ const fetchData = async () => {+ try {+ setIsLoading(true);+ setError(null);++ // Fetch trades+ const tradesResponse = await agnoTradingService.getAgentTrades(+ agentId || 'all',+ 100,+ filterStatus === 'all' ? undefined : filterStatus+ );++ if (tradesResponse.success && tradesResponse.data) {+ setTrades(tradesResponse.data.trades || []);+ }++ // Fetch performance if agent specified+ if (agentId) {+ const perfResponse = await agnoTradingService.getAgentPerformance(agentId);+ if (perfResponse.success && perfResponse.data) {+ setPerformance(perfResponse.data.performance);+ }+ }+ } catch (err) {+ console.error('Failed to fetch trade data:', err);+ setError(err instanceof Error ? err.message : String(err));+ } finally {+ setIsLoading(false);+ }+ };++ const handleSort = (field: SortField) => {+ if (sortField === field) {+ setSortDirection(sortDirection === 'asc' ? 'desc' : 'asc');+ } else {+ setSortField(field);+ setSortDirection('desc');+ }+ };++ const sortedTrades = [...trades].sort((a, b) => {+ const multiplier = sortDirection === 'asc' ? 1 : -1;++ switch (sortField) {+ case 'date':+ return (a.entry_timestamp - b.entry_timestamp) * multiplier;+ case 'symbol':+ return a.symbol.localeCompare(b.symbol) * multiplier;+ case 'pnl':+ return (a.pnl - b.pnl) * multiplier;+ case 'pnl_percent':+ return (a.pnl_percent - b.pnl_percent) * multiplier;+ default:+ return 0;+ }+ });++ return (+ <div style={{+ height: '100%',+ background: BLOOMBERG.PANEL_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '4px',+ display: 'flex',+ flexDirection: 'column',+ overflow: 'hidden'+ }}>+ {/* Header */}+ <div style={{+ background: BLOOMBERG.HEADER_BG,+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ padding: '8px 10px',+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between'+ }}>+ <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>+ <BarChart3 size={14} color={BLOOMBERG.CYAN} />+ <span style={{+ color: BLOOMBERG.WHITE,+ fontSize: '11px',+ fontWeight: '600',+ letterSpacing: '0.5px'+ }}>+ TRADE HISTORY+ </span>+ {isLoading && (+ <RefreshCw size={10} color={BLOOMBERG.ORANGE} className="animate-spin" />+ )}+ </div>++ <div style={{ display: 'flex', gap: '4px' }}>+ {/* Status Filter */}+ {['all', 'open', 'closed'].map(status => (+ <button+ key={status}+ onClick={() => setFilterStatus(status)}+ style={{+ background: filterStatus === status ? BLOOMBERG.ORANGE : 'transparent',+ border: `1px solid ${filterStatus === status ? BLOOMBERG.ORANGE : BLOOMBERG.BORDER}`,+ color: filterStatus === status ? BLOOMBERG.DARK_BG : BLOOMBERG.GRAY,+ padding: '2px 6px',+ borderRadius: '2px',+ fontSize: '8px',+ fontWeight: '700',+ cursor: 'pointer',+ transition: 'all 0.2s',+ textTransform: 'uppercase',+ letterSpacing: '0.3px'+ }}+ >+ {status}+ </button>+ ))}+ </div>+ </div>++ {/* Performance Summary */}+ {performance && (+ <div style={{+ background: BLOOMBERG.DARK_BG,+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ padding: '8px 10px',+ display: 'grid',+ gridTemplateColumns: 'repeat(4, 1fr)',+ gap: '8px'+ }}>+ <MetricCard+ label="TOTAL P&L"+ value={`$${performance.total_pnl.toFixed(2)}`}+ color={performance.total_pnl >= 0 ? BLOOMBERG.GREEN : BLOOMBERG.RED}+ />+ <MetricCard+ label="WIN RATE"+ value={`${performance.win_rate.toFixed(1)}%`}+ color={performance.win_rate >= 50 ? BLOOMBERG.GREEN : BLOOMBERG.RED}+ />+ <MetricCard+ label="SHARPE"+ value={performance.sharpe_ratio.toFixed(2)}+ color={performance.sharpe_ratio >= 1 ? BLOOMBERG.GREEN : BLOOMBERG.ORANGE}+ />+ <MetricCard+ label="TRADES"+ value={performance.total_trades.toString()}+ color={BLOOMBERG.CYAN}+ />+ <MetricCard+ label="DAILY P&L"+ value={`$${performance.daily_pnl.toFixed(2)}`}+ color={performance.daily_pnl >= 0 ? BLOOMBERG.GREEN : BLOOMBERG.RED}+ />+ <MetricCard+ label="MAX DD"+ value={`${performance.max_drawdown.toFixed(2)}%`}+ color={BLOOMBERG.RED}+ />+ <MetricCard+ label="PROFIT FACTOR"+ value={performance.profit_factor.toFixed(2)}+ color={performance.profit_factor >= 1.5 ? BLOOMBERG.GREEN : BLOOMBERG.ORANGE}+ />+ <MetricCard+ label="STREAK"+ value={`${performance.consecutive_wins}W / ${performance.consecutive_losses}L`}+ color={BLOOMBERG.GRAY}+ />+ </div>+ )}++ {/* Error Display */}+ {error && (+ <div style={{+ background: `${BLOOMBERG.RED}15`,+ border: `1px solid ${BLOOMBERG.RED}`,+ borderRadius: '2px',+ padding: '8px',+ margin: '8px',+ color: BLOOMBERG.RED,+ fontSize: '9px'+ }}>+ {error}+ </div>+ )}++ {/* Trade Table */}+ <div style={{+ flex: 1,+ overflow: 'auto',+ padding: '8px'+ }}>+ {trades.length === 0 && !isLoading && (+ <div style={{+ textAlign: 'center',+ color: BLOOMBERG.GRAY,+ fontSize: '10px',+ marginTop: '40px'+ }}>+ No trades yet+ </div>+ )}++ {trades.length > 0 && (+ <table style={{+ width: '100%',+ borderCollapse: 'collapse',+ fontSize: '9px',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ <thead>+ <tr style={{+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ color: BLOOMBERG.GRAY+ }}>+ <SortableHeader+ label="SYMBOL"+ field="symbol"+ currentField={sortField}+ direction={sortDirection}+ onSort={handleSort}+ />+ <th style={{ padding: '6px 4px', textAlign: 'left', fontSize: '8px', fontWeight: '700' }}>+ SIDE+ </th>+ <th style={{ padding: '6px 4px', textAlign: 'right', fontSize: '8px', fontWeight: '700' }}>+ ENTRY+ </th>+ <th style={{ padding: '6px 4px', textAlign: 'right', fontSize: '8px', fontWeight: '700' }}>+ EXIT+ </th>+ <SortableHeader+ label="P&L"+ field="pnl"+ currentField={sortField}+ direction={sortDirection}+ onSort={handleSort}+ align="right"+ />+ <SortableHeader+ label="P&L%"+ field="pnl_percent"+ currentField={sortField}+ direction={sortDirection}+ onSort={handleSort}+ align="right"+ />+ <th style={{ padding: '6px 4px', textAlign: 'center', fontSize: '8px', fontWeight: '700' }}>+ STATUS+ </th>+ <SortableHeader+ label="DATE"+ field="date"+ currentField={sortField}+ direction={sortDirection}+ onSort={handleSort}+ align="right"+ />+ </tr>+ </thead>+ <tbody>+ {sortedTrades.map((trade, idx) => (+ <TradeRow key={trade.id || idx} trade={trade} />+ ))}+ </tbody>+ </table>+ )}+ </div>+ </div>+ );+}++// ============================================================================+// Metric Card Component+// ============================================================================++interface MetricCardProps {+ label: string;+ value: string;+ color: string;+}++function MetricCard({ label, value, color }: MetricCardProps) {+ return (+ <div style={{+ background: BLOOMBERG.PANEL_BG,+ border: `1px solid ${BLOOMBERG.BORDER}`,+ borderRadius: '2px',+ padding: '4px 6px',+ display: 'flex',+ flexDirection: 'column',+ gap: '2px'+ }}>+ <span style={{+ color: BLOOMBERG.GRAY,+ fontSize: '7px',+ fontWeight: '700',+ letterSpacing: '0.5px'+ }}>+ {label}+ </span>+ <span style={{+ color: color,+ fontSize: '10px',+ fontWeight: '600',+ fontFamily: '"IBM Plex Mono", monospace'+ }}>+ {value}+ </span>+ </div>+ );+}++// ============================================================================+// Sortable Header Component+// ============================================================================++interface SortableHeaderProps {+ label: string;+ field: SortField;+ currentField: SortField;+ direction: SortDirection;+ onSort: (field: SortField) => void;+ align?: 'left' | 'right' | 'center';+}++function SortableHeader({+ label,+ field,+ currentField,+ direction,+ onSort,+ align = 'left'+}: SortableHeaderProps) {+ const isActive = currentField === field;++ return (+ <th+ onClick={() => onSort(field)}+ style={{+ padding: '6px 4px',+ textAlign: align,+ fontSize: '8px',+ fontWeight: '700',+ cursor: 'pointer',+ userSelect: 'none',+ transition: 'color 0.2s'+ }}+ onMouseEnter={(e) => {+ e.currentTarget.style.color = BLOOMBERG.ORANGE;+ }}+ onMouseLeave={(e) => {+ e.currentTarget.style.color = isActive ? BLOOMBERG.ORANGE : BLOOMBERG.GRAY;+ }}+ >+ <div style={{+ display: 'flex',+ alignItems: 'center',+ gap: '2px',+ justifyContent: align === 'right' ? 'flex-end' : align === 'center' ? 'center' : 'flex-start',+ color: isActive ? BLOOMBERG.ORANGE : BLOOMBERG.GRAY+ }}>+ {label}+ {isActive && (+ <ArrowUpDown size={8} style={{+ transform: direction === 'asc' ? 'rotate(180deg)' : 'none',+ transition: 'transform 0.2s'+ }} />+ )}+ </div>+ </th>+ );+}++// ============================================================================+// Trade Row Component+// ============================================================================++interface TradeRowProps {+ trade: AgentTrade;+}++function TradeRow({ trade }: TradeRowProps) {+ const pnlColor = trade.pnl >= 0 ? BLOOMBERG.GREEN : BLOOMBERG.RED;+ const statusColor = trade.status === 'open' ? BLOOMBERG.CYAN :+ trade.status === 'closed' ? BLOOMBERG.GRAY :+ BLOOMBERG.YELLOW;++ return (+ <tr+ style={{+ borderBottom: `1px solid ${BLOOMBERG.BORDER}`,+ transition: 'background 0.2s'+ }}+ onMouseEnter={(e) => {+ e.currentTarget.style.background = BLOOMBERG.HOVER;+ }}+ onMouseLeave={(e) => {+ e.currentTarget.style.background = 'transparent';+ }}+ >+ {/* Symbol */}+ <td style={{+ padding: '6px 4px',+ color: BLOOMBERG.WHITE,+ fontWeight: '600'+ }}>+ {trade.symbol}+ </td>++ {/* Side */}+ <td style={{+ padding: '6px 4px',+ color: trade.side === 'buy' ? BLOOMBERG.GREEN : BLOOMBERG.RED,+ fontWeight: '700',+ textTransform: 'uppercase'+ }}>+ {trade.side}+ </td>++ {/* Entry Price */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'right',+ color: BLOOMBERG.WHITE+ }}>+ ${trade.entry_price.toFixed(2)}+ </td>++ {/* Exit Price */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'right',+ color: trade.exit_price ? BLOOMBERG.WHITE : BLOOMBERG.MUTED+ }}>+ {trade.exit_price ? `$${trade.exit_price.toFixed(2)}` : '-'}+ </td>++ {/* P&L */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'right',+ color: pnlColor,+ fontWeight: '700'+ }}>+ {trade.pnl >= 0 ? '+' : ''}${trade.pnl.toFixed(2)}+ </td>++ {/* P&L % */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'right',+ color: pnlColor,+ fontWeight: '700'+ }}>+ {trade.pnl_percent >= 0 ? '+' : ''}{trade.pnl_percent.toFixed(2)}%+ </td>++ {/* Status */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'center'+ }}>+ <span style={{+ background: `${statusColor}20`,+ border: `1px solid ${statusColor}`,+ borderRadius: '2px',+ padding: '1px 4px',+ color: statusColor,+ fontSize: '7px',+ fontWeight: '700',+ textTransform: 'uppercase',+ letterSpacing: '0.3px'+ }}>+ {trade.status}+ </span>+ </td>++ {/* Date */}+ <td style={{+ padding: '6px 4px',+ textAlign: 'right',+ color: BLOOMBERG.GRAY,+ fontSize: '8px'+ }}>+ {new Date(trade.entry_timestamp * 1000).toLocaleDateString()}+ </td>+ </tr>+ );+}++export default TradeHistoryPanel;diff --git a/fincept-terminal-desktop/src/components/tabs/trading/hooks/usePositions.ts b/fincept-terminal-desktop/src/components/tabs/trading/hooks/usePositions.tsindex 1cb138763..89c7d3ee8 100644--- a/fincept-terminal-desktop/src/components/tabs/trading/hooks/usePositions.ts+++ b/fincept-terminal-desktop/src/components/tabs/trading/hooks/usePositions.ts@@ -59,7 +59,6 @@ export function usePositions(symbol?: string, autoRefresh: boolean = true, refresetPositions(normalized);setError(null); // Clear error on success- console.log('[usePositions] Successfully fetched', normalized.length, 'positions');} catch (err) {const error = err as Error;console.error('[usePositions] Failed to fetch positions:', error);diff --git a/fincept-terminal-desktop/src/paper-trading/PaperTradingAdapter.ts b/fincept-terminal-desktop/src/paper-trading/PaperTradingAdapter.tsindex 8acac6016..e338eea7d 100644--- a/fincept-terminal-desktop/src/paper-trading/PaperTradingAdapter.ts+++ b/fincept-terminal-desktop/src/paper-trading/PaperTradingAdapter.ts@@ -255,23 +255,16 @@ export class PaperTradingAdapter extends BaseExchangeAdapter {throw new Error('Paper trading adapter not initialized. Call connect() first.');}- console.log('[PaperTradingAdapter] fetchPositions called');-// FORCE FRESH DB READ - no cachingconst positions = await paperTradingDatabase.getPortfolioPositions(this.paperConfig.portfolioId, 'open');- console.log('[PaperTradingAdapter] Open positions:', positions.length);-- positions.forEach(p => {- console.log(` ${p.symbol} ${p.side} ${p.quantity} @ ${p.entryPrice}`);- });// Update positions with current prices - PARALLEL with timeout per positionconst updatePromises = positions.map(async (p) => {try {- // Add timeout per ticker fetch (5 seconds max)+ // Add timeout per ticker fetch (10 seconds max)const tickerPromise = this.realAdapter.fetchTicker(p.symbol);const timeoutPromise = new Promise((_, reject) =>- setTimeout(() => reject(new Error('Ticker timeout')), 5000)+ setTimeout(() => reject(new Error('Ticker timeout')), 10000));const ticker = await Promise.race([tickerPromise, timeoutPromise]) as any;@@ -289,8 +282,7 @@ export class PaperTradingAdapter extends BaseExchangeAdapter {p.currentPrice = currentPrice;p.unrealizedPnl = unrealizedPnl;} catch (err) {- console.warn(`[PaperTradingAdapter] Skipping price update for ${p.symbol}:`, err);- // Keep existing price if fetch fails+ // Silently keep existing price if fetch failsp.currentPrice = p.currentPrice || p.entryPrice;p.unrealizedPnl = p.unrealizedPnl || 0;}@@ -299,9 +291,9 @@ export class PaperTradingAdapter extends BaseExchangeAdapter {// Wait for all updates with overall timeoutawait Promise.race([Promise.all(updatePromises),- new Promise((_, reject) => setTimeout(() => reject(new Error('All updates timeout')), 10000))+ new Promise((_, reject) => setTimeout(() => reject(new Error('All updates timeout')), 20000))]).catch(() => {- console.warn('[PaperTradingAdapter] Some price updates timed out, continuing...');+ // Silently continue if some updates timeout});// Convert to CCXT Position formatdiff --git a/fincept-terminal-desktop/src/services/agnoTradingService.ts b/fincept-terminal-desktop/src/services/agnoTradingService.tsindex 653dc27f9..80b48e4c1 100644--- a/fincept-terminal-desktop/src/services/agnoTradingService.ts+++ b/fincept-terminal-desktop/src/services/agnoTradingService.ts@@ -168,6 +168,122 @@ export interface CompetitionResult {timestamp: string;}+// ============================================================================+// NEW TYPES: Auto-Trading, Debate, Evolution+// ============================================================================++export interface AgentTrade {+ id: number;+ agent_id: string;+ model: string;+ symbol: string;+ side: 'buy' | 'sell';+ order_type: string;+ quantity: number;+ entry_price: number;+ exit_price?: number;+ stop_loss?: number;+ take_profit?: number;+ pnl: number;+ pnl_percent: number;+ status: 'open' | 'closed' | 'cancelled';+ entry_timestamp: number;+ exit_timestamp?: number;+ reasoning?: string;+ metadata?: string;+ execution_time_ms?: number;+ is_paper_trade: boolean;+}++export interface AgentPerformance {+ agent_id: string;+ model: string;+ total_trades: number;+ winning_trades: number;+ losing_trades: number;+ total_pnl: number;+ daily_pnl: number;+ weekly_pnl: number;+ monthly_pnl: number;+ win_rate: number;+ sharpe_ratio: number;+ sortino_ratio: number;+ max_drawdown: number;+ current_drawdown: number;+ avg_win: number;+ avg_loss: number;+ profit_factor: number;+ largest_win: number;+ largest_loss: number;+ consecutive_wins: number;+ consecutive_losses: number;+ max_consecutive_wins: number;+ max_consecutive_losses: number;+ total_volume: number;+ positions: number;+ last_trade_timestamp?: number;+ last_updated: number;+}++export interface DebateResult {+ success: boolean;+ debate_id: string;+ symbol: string;+ bull_argument: string;+ bear_argument: string;+ analyst_decision: string;+ final_action: 'BUY' | 'SELL' | 'HOLD';+ confidence: number;+ entry_price?: number;+ stop_loss?: number;+ take_profit?: number;+ position_size?: number;+ reasoning?: string;+ execution_time_ms: number;+}++export interface Decision {+ id: number;+ agent_id: string;+ model: string;+ decision_type: 'analysis' | 'signal' | 'trade' | 'risk';+ symbol?: string;+ decision: string;+ reasoning?: string;+ confidence?: number;+ timestamp: number;+ execution_time_ms?: number;+}++export interface EvolutionCheck {+ should_evolve: boolean;+ trigger?: string;+ performance: AgentPerformance;+}++export interface EvolutionResult {+ success: boolean;+ agent_id: string;+ trigger: string;+ old_instructions: string[];+ new_instructions: string[];+ patterns: any;+ metrics_before: {+ total_pnl: number;+ win_rate: number;+ total_trades: number;+ };+}++export interface TradeExecutionResult {+ success: boolean;+ trade_id?: number;+ trade_data?: any;+ warnings?: string[];+ execution_time_ms?: number;+ error?: string;+}+// ============================================================================// Service Class// ============================================================================@@ -175,41 +291,38 @@ export interface CompetitionResult {class AgnoTradingService {/**- * Sync API keys from Settings to environment- * Called before each API request+ * Get API keys from Settings and build env var map+ * Returns a map of API keys in the format: { OPENAI_API_KEY: "sk-...", ... }*/- private async syncApiKeys(): Promise<void> {+ private async getApiKeysMap(): Promise<Record<string, string>> {try {const configs = await sqliteService.getLLMConfigs();- // Map provider names to environment variable format- const keyMap: Record<string, string> = {- 'openai': 'OPENAI_API_KEY',- 'anthropic': 'ANTHROPIC_API_KEY',- 'google': 'GOOGLE_API_KEY',- 'groq': 'GROQ_API_KEY',- 'deepseek': 'DEEPSEEK_API_KEY',- 'xai': 'XAI_API_KEY',- 'cohere': 'COHERE_API_KEY',- 'mistral': 'MISTRAL_API_KEY',- 'together': 'TOGETHER_API_KEY',- 'fireworks': 'FIREWORKS_API_KEY'- };-- // Send API keys to Rust backend- for (const config of configs) {- if (config.api_key && keyMap[config.provider]) {- await invoke('set_env_var', {- key: keyMap[config.provider],- value: config.api_key- }).catch(() => {- // Ignore errors - backend may not support this command- console.log(`Could not sync ${config.provider} API key to backend`);- });+ // Build API keys map+ const apiKeys: Record<string, string> = {};+ configs.forEach(config => {+ if (config.api_key) {+ const provider = config.provider.toLowerCase();++ // Map provider name to standard env var format+ // Handle aliases: gemini -> google+ let standardProvider = provider;+ if (provider === 'gemini') {+ standardProvider = 'google';+ // Also add GEMINI_API_KEY for backward compatibility+ apiKeys['GEMINI_API_KEY'] = config.api_key;+ }++ // Format: OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY, etc.+ const keyName = `${standardProvider.toUpperCase()}_API_KEY`;+ apiKeys[keyName] = config.api_key;}- }+ });++ return apiKeys;} catch (error) {- console.warn('Failed to sync API keys:', error);+ console.warn('Failed to load API keys:', error);+ return {};}}@@ -318,10 +431,14 @@ class AgnoTradingService {analysisType: 'quick' | 'comprehensive' | 'deep' = 'comprehensive'): Promise<AgnoResponse<MarketAnalysis>> {try {+ // Get API keys from Settings+ const apiKeys = await this.getApiKeysMap();+const response = await invoke<string>('agno_analyze_market', {symbol,agentModel,- analysisType+ analysisType,+ apiKeysJson: JSON.stringify(apiKeys)});return JSON.parse(response);} catch (error) {@@ -342,11 +459,15 @@ class AgnoTradingService {marketData?: any): Promise<AgnoResponse<TradeSignal>> {try {+ // Get API keys from Settings+ const apiKeys = await this.getApiKeysMap();+const response = await invoke<string>('agno_generate_trade_signal', {symbol,strategy,agentModel,- marketData: marketData ? JSON.stringify(marketData) : undefined+ marketData: marketData ? JSON.stringify(marketData) : undefined,+ apiKeysJson: JSON.stringify(apiKeys)});return JSON.parse(response);} catch (error) {@@ -369,10 +490,14 @@ class AgnoTradingService {riskTolerance: 'conservative' | 'moderate' | 'aggressive' = 'moderate'): Promise<AgnoResponse<RiskAnalysis>> {try {+ // Get API keys from Settings+ const apiKeys = await this.getApiKeysMap();+const response = await invoke<string>('agno_manage_risk', {portfolioData: JSON.stringify(portfolioData),agentModel,- riskTolerance+ riskTolerance,+ apiKeysJson: JSON.stringify(apiKeys)});return JSON.parse(response);} catch (error) {@@ -414,12 +539,15 @@ class AgnoTradingService {models: string[],taskType: 'trading' | 'analysis' | 'research' = 'trading'): Promise<AgnoResponse<CompetitionInfo>> {- await this.syncApiKeys();try {+ // Get API keys from Settings+ const apiKeys = await this.getApiKeysMap();+const response = await invoke<string>('agno_create_competition', {name,modelsJson: JSON.stringify(models),- taskType+ taskType,+ apiKeysJson: JSON.stringify(apiKeys)});return JSON.parse(response);} catch (error) {@@ -438,12 +566,15 @@ class AgnoTradingService {symbol: string,task: 'analyze' | 'signal' | 'evaluate' = 'analyze'): Promise<AgnoResponse<CompetitionResult>> {- await this.syncApiKeys();try {+ // Get API keys from Settings+ const apiKeys = await this.getApiKeysMap();+const response = await invoke<string>('agno_run_competition', {teamId,symbol,- task+ task,+ apiKeysJson: JSON.stringify(apiKeys)});return JSON.parse(response);} catch (error) {@@ -589,6 +720,279 @@ class AgnoTradingService {const [provider, model] = modelString.split(':');return { provider, model };}++ // ============================================================================+ // NEW METHODS: Auto-Trading, Debate, Evolution+ // ============================================================================++ /**+ * Execute a trade based on signal+ */+ async executeTrade(+ signal: TradeSignal & { side?: string; quantity?: number; entry_price?: number; stop_loss?: number; take_profit?: number },+ portfolio: { total_value: number; positions: any[]; daily_pnl: number },+ agentId: string,+ model: string+ ): Promise<AgnoResponse<TradeExecutionResult>> {+ try {+ const apiKeysMap = await this.getApiKeysMap();++ const response = await invoke('agno_execute_trade', {+ signalJson: JSON.stringify(signal),+ portfolioJson: JSON.stringify(portfolio),+ agentId,+ model,+ apiKeysJson: JSON.stringify(apiKeysMap)+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Execute trade error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Close an open position+ */+ async closePosition(+ tradeId: number,+ exitPrice: number,+ reason: string = 'manual'+ ): Promise<AgnoResponse<any>> {+ try {+ const response = await invoke('agno_close_position', {+ tradeId,+ exitPrice,+ reason+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Close position error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get trade history for an agent+ */+ async getAgentTrades(+ agentId: string,+ limit: number = 100,+ status?: string+ ): Promise<AgnoResponse<{ trades: AgentTrade[] }>> {+ try {+ const response = await invoke('agno_get_agent_trades', {+ agentId,+ limit,+ status+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get agent trades error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get performance metrics for an agent+ */+ async getAgentPerformance(+ agentId: string+ ): Promise<AgnoResponse<{ performance: AgentPerformance }>> {+ try {+ const response = await invoke('agno_get_agent_performance', {+ agentId+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get agent performance error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get leaderboard from database+ */+ async getDbLeaderboard(+ limit: number = 20+ ): Promise<AgnoResponse<{ leaderboard: AgentPerformance[] }>> {+ try {+ const response = await invoke('agno_get_db_leaderboard', {+ limit+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get leaderboard error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get recent decisions from database+ */+ async getDbDecisions(+ limit: number = 50,+ agentId?: string+ ): Promise<AgnoResponse<{ decisions: Decision[] }>> {+ try {+ const response = await invoke('agno_get_db_decisions', {+ limit,+ agentId+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get decisions error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Run a Bull/Bear/Analyst debate+ */+ async runDebate(+ symbol: string,+ marketData: any,+ bullModel: string,+ bearModel: string,+ analystModel: string+ ): Promise<AgnoResponse<DebateResult>> {+ try {+ const apiKeysMap = await this.getApiKeysMap();++ const response = await invoke('agno_run_debate', {+ symbol,+ marketDataJson: JSON.stringify(marketData),+ bullModel,+ bearModel,+ analystModel,+ apiKeysJson: JSON.stringify(apiKeysMap)+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Run debate error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get recent debate sessions+ */+ async getRecentDebates(+ limit: number = 10+ ): Promise<AgnoResponse<{ debates: any[] }>> {+ try {+ const response = await invoke('agno_get_recent_debates', {+ limit+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get debates error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Check if agent should evolve+ */+ async checkEvolution(+ agentId: string+ ): Promise<AgnoResponse<EvolutionCheck>> {+ try {+ const response = await invoke('agno_check_evolution', {+ agentId+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Check evolution error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Evolve an agent based on performance+ */+ async evolveAgent(+ agentId: string,+ model: string,+ currentInstructions: string[],+ trigger: string,+ notes?: string+ ): Promise<AgnoResponse<EvolutionResult>> {+ try {+ const response = await invoke('agno_evolve_agent', {+ agentId,+ model,+ currentInstructionsJson: JSON.stringify(currentInstructions),+ trigger,+ notes+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Evolve agent error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }++ /**+ * Get evolution summary for an agent+ */+ async getEvolutionSummary(+ agentId: string+ ): Promise<AgnoResponse<any>> {+ try {+ const response = await invoke('agno_get_evolution_summary', {+ agentId+ });++ return this.parseResponse(response);+ } catch (error) {+ console.error('[AgnoService] Get evolution summary error:', error);+ return {+ success: false,+ error: error instanceof Error ? error.message : String(error)+ };+ }+ }}// ============================================================================