Add Analyzer (metrics) and FastAPI backend

core/analyzer.py

@@ -0,0 +1,219 @@
+"""Analysis tools for DeFi agent simulation metrics."""
+
+from typing import List, Dict, Optional
+from collections import Counter
+import statistics
+
+
+class Analyzer:
+    """Calculate and analyze simulation metrics."""
+
+    @staticmethod
+    def calculate_run_metrics(agents: List, pool) -> Dict:
+        """Calculate all metrics for a completed run."""
+        profits = [a.calculate_profit() for a in agents]
+
+        return {
+            "gini_coefficient": Analyzer.gini_coefficient(profits),
+            "avg_agent_profit": statistics.mean(profits) if profits else 0,
+            "min_profit": min(profits) if profits else 0,
+            "max_profit": max(profits) if profits else 0,
+            "total_trades": Analyzer.count_trades(agents),
+            "cooperation_rate": Analyzer.cooperation_rate(agents),
+            "pool_stability": pool.reserve_a * pool.reserve_b,
+            "pool_price_change": Analyzer.price_change(pool)
+        }
+
+    @staticmethod
+    def gini_coefficient(values: List[float]) -> float:
+        """Calculate Gini coefficient (wealth inequality 0-1)."""
+        if not values or sum(values) == 0:
+            return 0
+
+        sorted_vals = sorted(values)
+        n = len(sorted_vals)
+        cumsum = sum((i + 1) * val for i, val in enumerate(sorted_vals))
+
+        gini = (2 * cumsum) / (n * sum(sorted_vals)) - (n + 1) / n
+        return max(0, min(1, gini))  # Clamp to 0-1
+
+    @staticmethod
+    def count_trades(agents: List) -> int:
+        """Count total trades across all agents."""
+        return sum(
+            len([h for h in a.trade_history if h.get("action") == "swap"])
+            for a in agents
+        )
+
+    @staticmethod
+    def cooperation_rate(agents: List) -> float:
+        """Calculate cooperation rate (alliances per agent)."""
+        total_alliances = sum(len(a.alliances) for a in agents)
+        return total_alliances / max(len(agents), 1)
+
+    @staticmethod
+    def price_change(pool) -> float:
+        """Calculate pool price change from initial (placeholder)."""
+        return 0  # Would need to track initial price
+
+    @staticmethod
+    def detect_arms_races(actions: List[Dict]) -> Dict:
+        """Detect strategic arms race patterns across agents."""
+        strategies = {}
+        for action in actions:
+            agent = action.get("agent_name", "unknown")
+            action_type = action.get("action_type", action.get("action", "unknown"))
+
+            if agent not in strategies:
+                strategies[agent] = []
+            strategies[agent].append(action_type)
+
+        analysis = {}
+        for agent, actions_list in strategies.items():
+            if not actions_list:
+                continue
+
+            counter = Counter(actions_list)
+            most_common = counter.most_common(1)[0]
+
+            analysis[agent] = {
+                "dominant_strategy": most_common[0],
+                "strategy_counts": dict(counter),
+                "strategy_diversity": len(set(actions_list)) / len(actions_list),
+                "aggressiveness": Analyzer._calculate_aggressiveness(actions_list)
+            }
+
+        return analysis
+
+    @staticmethod
+    def _calculate_aggressiveness(actions: List[str]) -> float:
+        """Calculate aggressiveness score (0-1)."""
+        aggressive_actions = {"swap", "provide_liquidity"}
+        passive_actions = {"do_nothing"}
+
+        aggressive_count = sum(1 for a in actions if a in aggressive_actions)
+        passive_count = sum(1 for a in actions if a in passive_actions)
+
+        total = len(actions)
+        if total == 0:
+            return 0.5
+
+        return aggressive_count / total
+
+    @staticmethod
+    def detect_trends(runs: List[Dict]) -> Dict:
+        """Detect trends across multiple runs."""
+        if not runs:
+            return {}
+
+        profits = [r.get("avg_agent_profit", 0) for r in runs]
+        gini = [r.get("gini_coefficient", 0) for r in runs]
+
+        return {
+            "profit_trend": Analyzer._trend_direction(profits),
+            "inequality_trend": Analyzer._trend_direction(gini),
+            "avg_profit": statistics.mean(profits) if profits else 0,
+            "avg_gini": statistics.mean(gini) if gini else 0,
+            "run_count": len(runs)
+        }
+
+    @staticmethod
+    def _trend_direction(values: List[float]) -> str:
+        """Get trend direction (up, down, stable)."""
+        if len(values) < 2:
+            return "stable"
+
+        first_half = statistics.mean(values[:len(values)//2])
+        second_half = statistics.mean(values[len(values)//2:])
+
+        diff = second_half - first_half
+        if diff > 0.1:
+            return "up"
+        elif diff < -0.1:
+            return "down"
+        return "stable"
+
+    @staticmethod
+    def format_report(metrics: Dict, agent_count: int = 5) -> str:
+        """Format metrics as a readable report."""
+        lines = [
+            "=" * 40,
+            "SIMULATION REPORT",
+            "=" * 40,
+            f"Agents: {agent_count}",
+            "-" * 40,
+            f"Gini Coefficient: {metrics.get('gini_coefficient', 0):.4f}",
+            f"Avg Profit: {metrics.get('avg_agent_profit', 0):.2f}",
+            f"Total Trades: {metrics.get('total_trades', 0)}",
+            f"Cooperation Rate: {metrics.get('cooperation_rate', 0):.2f}",
+            f"Pool Stability: {metrics.get('pool_stability', 0):.2f}",
+            "=" * 40,
+        ]
+
+        # Add inequality interpretation
+        gini = metrics.get('gini_coefficient', 0)
+        if gini < 0.2:
+            interpretation = "Low inequality"
+        elif gini < 0.4:
+            interpretation = "Moderate inequality"
+        else:
+            interpretation = "High inequality"
+        lines.append(f"Inequality: {interpretation}")
+
+        return "\n".join(lines)
+
+
+def test_analyzer():
+    """Test the Analyzer class."""
+    print("Testing Analyzer class...")
+
+    # Create mock agents
+    class MockAgent:
+        def __init__(self, name, profit, alliances, trades):
+            self.name = name
+            self.profit = profit
+            self.alliances = alliances
+            self.trade_history = [{"action": t} for t in trades]
+
+        def calculate_profit(self):
+            return self.profit
+
+    agents = [
+        MockAgent("A", 50, {"B": "ally"}, ["swap", "do_nothing"]),
+        MockAgent("B", 30, {"A": "ally"}, ["swap"]),
+        MockAgent("C", -20, {}, ["do_nothing", "do_nothing"]),
+        MockAgent("D", 40, {}, ["provide_liquidity"]),
+        MockAgent("E", 0, {}, ["do_nothing"]),
+    ]
+
+    class MockPool:
+        reserve_a = 1100
+        reserve_b = 909
+        price_ab = 0.826
+
+    # Calculate metrics
+    metrics = Analyzer.calculate_run_metrics(agents, MockPool())
+
+    print("\nMetrics:")
+    for k, v in metrics.items():
+        print(f"  {k}: {v}")
+
+    # Format report
+    print("\n" + Analyzer.format_report(metrics))
+
+    # Arms race detection
+    actions = [
+        {"agent_name": "A", "action_type": "swap"},
+        {"agent_name": "B", "action_type": "swap"},
+        {"agent_name": "A", "action_type": "provide_liquidity"},
+    ]
+    arms_race = Analyzer.detect_arms_races(actions)
+    print("\nArms Race Analysis:")
+    for agent, data in arms_race.items():
+        print(f"  {agent}: {data}")
+
+    print("\nAnalyzer test complete!")
+
+
+if __name__ == "__main__":
+    test_analyzer()

web/__init__.py

@@ -1 +1,5 @@
 """Web API components for DeFi Agents simulation."""
+
+from .app import app, run_server
+
+__all__ = ["app", "run_server"]

web/app.py

@@ -0,0 +1,206 @@
+"""FastAPI backend for DeFi Agents simulation dashboard."""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+import json
+
+from api.supabase_client import SupabaseClient
+from core.simulation import Simulation
+from core.analyzer import Analyzer
+
+app = FastAPI(
+    title="DeFi Agents API",
+    description="Multi-agent LLM simulation in DeFi markets",
+    version="0.1.0"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize clients
+supabase = None
+try:
+    supabase = SupabaseClient()
+except ValueError:
+    print("Warning: Supabase not configured")
+
+
+# ==================== Pydantic Models ====================
+
+class RunRequest(BaseModel):
+    num_agents: int = 5
+    turns_per_run: int = 10
+
+
+class RunResponse(BaseModel):
+    run_number: int
+    metrics: Dict[str, Any]
+    agents: List[Dict[str, Any]]
+
+
+class AgentActionRequest(BaseModel):
+    agent_name: str
+    action: str
+    payload: Dict = {}
+
+
+# ==================== Health Endpoints ====================
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "supabase": "connected" if supabase and supabase.health_check() else "disconnected"
+    }
+
+
+# ==================== Run Endpoints ====================
+
+@app.post("/api/runs")
+def create_run(request: RunRequest):
+    """Start a new simulation run."""
+    try:
+        sim = Simulation(
+            num_agents=request.num_agents,
+            turns_per_run=request.turns_per_run,
+            supabase=supabase
+        )
+
+        metrics = sim.run()
+
+        # Get agent states
+        agent_data = []
+        for agent in sim.agents:
+            agent_data.append({
+                "name": agent.name,
+                "token_a": agent.token_a,
+                "token_b": agent.token_b,
+                "profit": agent.calculate_profit(),
+                "strategy": agent.infer_strategy()
+            })
+
+        return RunResponse(
+            run_number=sim.current_run_number - 1,
+            metrics=metrics,
+            agents=agent_data
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/runs")
+def get_all_runs():
+    """Get all runs."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        runs = supabase.get_all_runs()
+        return {"runs": runs}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/runs/{run_id}")
+def get_run_detail(run_id: int):
+    """Get detailed run data."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        detail = supabase.get_run_detail(run_id)
+        return detail
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== Metrics Endpoints ====================
+
+@app.get("/api/metrics/{run_id}")
+def get_run_metrics(run_id: int):
+    """Get metrics for a specific run."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        metrics = supabase.get_metrics(run_id)
+        if not metrics:
+            raise HTTPException(status_code=404, detail="Run not found")
+        return metrics
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/analysis/trends")
+def get_trends():
+    """Get trend analysis across all runs."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        runs = supabase.get_all_runs()
+        run_data = [r for r in runs if r.get("status") == "completed"]
+
+        metrics = []
+        for r in run_data:
+            run_metrics = supabase.get_metrics(r["id"])
+            if run_metrics:
+                metrics.append(run_metrics)
+
+        trends = Analyzer.detect_trends(metrics)
+        return trends
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== Thinking/Reasoning Endpoints ====================
+
+@app.get("/api/thinking/{action_id}")
+def get_thinking_trace(action_id: int):
+    """Get the thinking trace for a specific action."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        thinking = supabase.get_thinking_trace(action_id)
+        if thinking is None:
+            raise HTTPException(status_code=404, detail="Action not found")
+        return {"thinking": thinking}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== Analysis Endpoints ====================
+
+@app.get("/api/analysis/arms-race/{run_id}")
+def get_arms_race_analysis(run_id: int):
+    """Detect arms race patterns in a run."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        actions = supabase.get_actions(run_id)
+        analysis = Analyzer.detect_arms_races(actions)
+        return analysis
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def run_server():
+    """Run the FastAPI server."""
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    print("Starting DeFi Agents API server on http://0.0.0.0:8000")
+    run_server()