Upload agents/runner.py with huggingface_hub

agents/runner.py

@@ -0,0 +1,191 @@
+"""
+Portfolio Runner — Orchestrates the CGAE Adaptive Portfolio Manager demo.
+
+Flow:
+  1. Create sub-agents (RegimeDetector, Rebalancer, YieldOptimizer)
+  2. Run portfolio management cycles
+  3. Adversarial agent attacks each cycle — all blocked by CGAE
+  4. Display results
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+import urllib.request
+from typing import Optional
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from cgae_engine.gate import GateFunction, RobustnessVector, Tier
+from cgae_engine.llm_agent import create_llm_agents
+from cgae_engine.models_config import CONTESTANT_MODELS
+from cgae_engine.audit import AuditOrchestrator
+from agents.portfolio import (
+    PortfolioOrchestrator, RegimeDetector, Rebalancer,
+    YieldOptimizer, SubAgent, Allocation, Regime,
+)
+from agents.adversarial import AdversarialAgent
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_market_data() -> dict:
+    """Fetch live market data for regime detection."""
+    try:
+        url = "https://api.coingecko.com/api/v3/simple/price?ids=ethereum,bitcoin&vs_currencies=usd&include_24hr_change=true"
+        req = urllib.request.Request(url, headers={"Accept": "application/json"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        return {
+            "eth_change_24h": data["ethereum"].get("usd_24h_change", 0),
+            "btc_change_24h": data["bitcoin"].get("usd_24h_change", 0),
+            "volatility": abs(data["ethereum"].get("usd_24h_change", 0)) * 0.5,
+            "funding_rate": 0.01,
+            "fear_greed": 55,
+        }
+    except Exception as e:
+        logger.warning(f"Market data fetch failed: {e}")
+        return {"eth_change_24h": 1.5, "btc_change_24h": 0.8, "volatility": 3.0, "funding_rate": 0.01, "fear_greed": 55}
+
+
+def create_portfolio_system() -> tuple[PortfolioOrchestrator, AdversarialAgent]:
+    """Create the full portfolio system with all sub-agents."""
+    gate = GateFunction()
+    models = {m["model_name"]: m for m in CONTESTANT_MODELS}
+    llm_agents = create_llm_agents(list(models.values()))
+
+    # Fetch real robustness scores from framework APIs where available
+    orchestrator_audit = AuditOrchestrator()
+    agent_scores = {}
+    for name in ["nova-pro", "DeepSeek-V3.2", "Kimi-K2.5", "MiniMax-M2.5"]:
+        result = orchestrator_audit.audit_from_results(name, name)
+        agent_scores[name] = result.robustness
+        defaults = result.defaults_used
+        tier = gate.evaluate(result.robustness)
+        logger.info(f"  {name}: CC={result.robustness.cc:.3f} ER={result.robustness.er:.3f} "
+                    f"AS={result.robustness.as_:.3f} IH={result.robustness.ih:.3f} → T{tier.value}"
+                    f"{' (defaults: ' + ','.join(defaults) + ')' if defaults else ''}")
+
+    regime_r = agent_scores["nova-pro"]
+    rebal_r = agent_scores["Kimi-K2.5"]
+    yield_r = agent_scores["DeepSeek-V3.2"]
+
+    regime_detector = RegimeDetector(
+        name="nova-pro", role="regime_detector",
+        llm=llm_agents["nova-pro"],
+        tier=gate.evaluate(regime_r),
+        robustness=regime_r,
+    ) if "nova-pro" in llm_agents else None
+
+    rebalancer = Rebalancer(
+        name="Kimi-K2.5", role="rebalancer",
+        llm=llm_agents["Kimi-K2.5"],
+        tier=gate.evaluate(rebal_r),
+        robustness=rebal_r,
+    ) if "Kimi-K2.5" in llm_agents else None
+
+    yield_optimizer = YieldOptimizer(
+        name="DeepSeek-V3.2", role="yield_optimizer",
+        llm=llm_agents["DeepSeek-V3.2"],
+        tier=gate.evaluate(yield_r),
+        robustness=yield_r,
+    ) if "DeepSeek-V3.2" in llm_agents else None
+
+    if not all([regime_detector, rebalancer, yield_optimizer]):
+        raise RuntimeError("Could not create all sub-agents. Check AWS credentials.")
+
+    orchestrator = PortfolioOrchestrator(
+        regime_detector=regime_detector,
+        rebalancer=rebalancer,
+        yield_optimizer=yield_optimizer,
+        tier=Tier.T4,  # Orchestrator has highest tier
+    )
+
+    # MiniMax-M2.5 as adversary — uses its real (low) robustness scores
+    minimax_r = agent_scores["MiniMax-M2.5"]
+    minimax_tier = gate.evaluate(minimax_r)
+    adversary = AdversarialAgent(tier=minimax_tier, robustness=minimax_r)
+
+    return orchestrator, adversary
+
+
+def run_demo(rounds: int = 2, interval: int = 5):
+    """Run the full portfolio management demo with adversary attacks."""
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    print("=" * 65)
+    print("  CGAE Adaptive Portfolio Manager — Arc × Circle (RFB 04)")
+    print("=" * 65)
+
+    orchestrator, adversary = create_portfolio_system()
+
+    # Print agent roster
+    print(f"\n{'─' * 65}")
+    print("  AGENT ROSTER")
+    print(f"{'─' * 65}")
+    agents = [
+        ("Orchestrator", "coordinator", Tier.T4),
+        (orchestrator.regime_detector.name, "regime_detector", orchestrator.regime_detector.tier),
+        (orchestrator.rebalancer.name, "rebalancer", orchestrator.rebalancer.tier),
+        (orchestrator.yield_optimizer.name, "yield_optimizer", orchestrator.yield_optimizer.tier),
+        ("adversary", "adversarial", adversary.tier),
+    ]
+    print(f"  {'Agent':<20} {'Role':<18} {'Tier':<5} {'Budget':<10}")
+    print(f"  {'-'*53}")
+    for name, role, tier in agents:
+        budget = f"${GateFunction().budget_ceiling(tier)}"
+        print(f"  {name:<20} {role:<18} T{tier.value:<4} {budget}")
+
+    # Run cycles
+    for i in range(rounds):
+        print(f"\n{'═' * 65}")
+        print(f"  CYCLE {i+1}/{rounds}")
+        print(f"{'═' * 65}")
+
+        # Portfolio management
+        print(f"\n  📈 Portfolio Management")
+        print(f"  {'─' * 40}")
+        market = fetch_market_data()
+        result = orchestrator.run_cycle(market)
+
+        # Adversary attacks
+        print(f"\n  🔴 Adversary Attacks")
+        print(f"  {'─' * 40}")
+        attacks = adversary.run_all_attacks()
+        for attack in attacks:
+            status = "⛔ BLOCKED" if attack.blocked else "⚠️  PASSED"
+            print(f"  {status}: {attack.attack_type.value}")
+            print(f"    └─ {attack.description}")
+
+        if i < rounds - 1:
+            time.sleep(interval)
+
+    # Final summary
+    print(f"\n{'═' * 65}")
+    print("  FINAL STATE")
+    print(f"{'═' * 65}")
+    ps = orchestrator.summary()
+    print(f"\n  Portfolio: ${ps['aum']:.2f} AUM | Regime: {ps['regime']}")
+    print(f"  Allocation: ETH={ps['allocation']['eth']:.0f}% BTC={ps['allocation']['btc']:.0f}% "
+          f"USDC={ps['allocation']['usdc']:.0f}% USYC={ps['allocation']['usyc']:.0f}%")
+    print(f"  Delegations: {ps['total_delegations']} | Blocks: {ps['total_blocks']}")
+
+    pay = ps.get("payments", {})
+    if pay:
+        print(f"\n  💸 Nanopayments (x402 via Gateway):")
+        print(f"     Spent: ${pay.get('spent', 0):.4f} / ${pay.get('budget_ceiling', 0)} ceiling")
+        print(f"     Payments: {pay.get('payments_made', 0)} made, {pay.get('payments_blocked', 0)} blocked")
+
+    adv = adversary.summary()
+    print(f"\n  Adversary: {adv['blocked']}/{adv['total_attacks']} attacks blocked "
+          f"({(1-adv['success_rate'])*100:.0f}% defense rate)")
+    print(f"  Theorems enforced: {', '.join(set(a['theorem'][:20]+'...' for a in adv['attacks']))}")
+
+    return {"portfolio": ps, "adversary": adv}
+
+
+if __name__ == "__main__":
+    run_demo()