Add summary and agent profit methods to supabase client

api/supabase_client.py

@@ -72,6 +72,13 @@ class MetricsData:
     pool_stability: float = 0
 
 
+@dataclass
+class SummaryData:
+    """Data class for run summary."""
+    run_id: int
+    summary_text: str
+
+
 class SupabaseClient:
     """Client for interacting with Supabase database."""
 
@@ -240,6 +247,39 @@ class SupabaseClient:
             "metrics": metrics
         }
 
+    # ==================== RUN SUMMARIES ====================
+
+    def save_run_summary(self, data: SummaryData):
+        """Save a run summary to database."""
+        self.client.table("run_summaries").insert({
+            "run_id": data.run_id,
+            "summary_text": data.summary_text
+        }).execute()
+
+    def get_run_summary(self, run_id: int) -> Optional[Dict]:
+        """Get summary for a specific run."""
+        response = self.client.table("run_summaries").select("*").eq("run_id", run_id).execute()
+        return response.data[0] if response.data else None
+
+    def get_all_summaries(self) -> List[Dict]:
+        """Get all run summaries."""
+        response = self.client.table("run_summaries").select("*").order("run_id", desc=True).execute()
+        return response.data
+
+    # ==================== AGENT PROFITS ====================
+
+    def get_agent_profits_all_runs(self, agent_name: str) -> List[Dict]:
+        """Get profit history for an agent across all runs."""
+        # Get the latest state for each run for this agent
+        response = self.client.table("agent_states").select("*").eq("agent_name", agent_name).order("run_id").execute()
+        return response.data
+
+    def get_all_agent_names(self) -> List[str]:
+        """Get all unique agent names."""
+        response = self.client.table("agent_states").select("agent_name").execute()
+        names = set(item["agent_name"] for item in response.data)
+        return sorted(list(names))
+
     # ==================== UTILITY ====================
 
     def health_check(self) -> bool:

core/simulation.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 
 from core.agent import Agent
 from core.defi_mechanics import Pool
+from core.summarizer import Summarizer
 from api.supabase_client import (
     SupabaseClient, RunData, AgentStateData, PoolStateData, ActionData, MetricsData
 )
@@ -93,6 +94,14 @@ class Simulation:
                 )
             )
 
+            # Generate and save run summary
+            try:
+                summarizer = Summarizer(supabase=self.supabase)
+                summary = summarizer.summarize_and_save(self.current_run_id)
+                print(f"Generated summary for run {self.current_run_id}")
+            except Exception as e:
+                print(f"Warning: Failed to generate summary - {e}")
+
         # Update agent learning
         for agent in self.agents:
             agent.update_learning(self.current_run_number, metrics)

core/summarizer.py

@@ -0,0 +1,172 @@
+"""Run summarizer agent using MiniMax LLM."""
+
+from typing import Dict, List, Any
+from api.minimax_client import MiniMaxClient
+from api.supabase_client import SupabaseClient, SummaryData
+
+
+class Summarizer:
+    """Agent that generates detailed summaries of simulation runs."""
+
+    def __init__(self, supabase: SupabaseClient = None):
+        self.supabase = supabase
+        self.minimax = MiniMaxClient()
+
+    def generate_summary(self, run_id: int) -> str:
+        """Generate a detailed summary for a run."""
+        # Get run data
+        run_detail = self.supabase.get_run_detail(run_id)
+        metrics = run_detail.get("metrics", {})
+        actions = run_detail.get("actions", [])
+        agent_states = run_detail.get("agent_states", [])
+        pool_states = run_detail.get("pool_states", [])
+
+        # Get run info
+        runs = self.supabase.get_all_runs()
+        run_info = next((r for r in runs if r["id"] == run_id), {})
+        run_number = run_info.get("run_number", run_id)
+
+        # Analyze data
+        agent_performance = self._analyze_agents(agent_states)
+        action_distribution = self._analyze_actions(actions)
+        market_events = self._analyze_market_events(actions, pool_states)
+
+        # Build prompt
+        prompt = self._build_summary_prompt(
+            run_number=run_number,
+            metrics=metrics,
+            agent_performance=agent_performance,
+            action_distribution=action_distribution,
+            market_events=market_events
+        )
+
+        # Generate summary using LLM
+        response = self.minimax.complete(prompt, max_tokens=1024)
+
+        return response.strip()
+
+    def _analyze_agents(self, agent_states: List[Dict]) -> List[Dict]:
+        """Analyze agent performance."""
+        # Get latest state for each agent
+        latest_by_agent = {}
+        for state in agent_states:
+            agent = state["agent_name"]
+            if agent not in latest_by_agent or state["turn"] > latest_by_agent[agent]["turn"]:
+                latest_by_agent[agent] = state
+
+        performance = []
+        for agent, state in latest_by_agent.items():
+            performance.append({
+                "name": agent,
+                "profit": state.get("profit", 0),
+                "strategy": state.get("strategy", "unknown"),
+                "final_tokens": f"{state.get('token_a_balance', 0):.0f}A / {state.get('token_b_balance', 0):.0f}B"
+            })
+
+        # Sort by profit descending
+        performance.sort(key=lambda x: x["profit"], reverse=True)
+        return performance
+
+    def _analyze_actions(self, actions: List[Dict]) -> Dict[str, int]:
+        """Count action types."""
+        distribution = {}
+        for action in actions:
+            action_type = action.get("action_type", "unknown")
+            distribution[action_type] = distribution.get(action_type, 0) + 1
+        return distribution
+
+    def _analyze_market_events(self, actions: List[Dict], pool_states: List[Dict]) -> List[str]:
+        """Identify notable market events."""
+        events = []
+
+        # Find significant pool changes
+        if len(pool_states) >= 2:
+            first_reserve = pool_states[0]
+            last_reserve = pool_states[-1]
+
+            if first_reserve and last_reserve:
+                reserve_a_change = last_reserve["reserve_a"] - first_reserve["reserve_a"]
+                reserve_b_change = last_reserve["reserve_b"] - first_reserve["reserve_b"]
+
+                if abs(reserve_a_change) > 100 or abs(reserve_b_change) > 100:
+                    events.append(f"Pool shifted: A {reserve_a_change:+.0f}, B {reserve_b_change:+.0f}")
+
+        # Count alliances
+        alliances = [a for a in actions if a.get("action_type") == "propose_alliance"]
+        if len(alliances) > 3:
+            events.append(f"{len(alliances)} alliance proposals made")
+
+        # Count trades
+        trades = [a for a in actions if a.get("action_type") == "swap"]
+        if len(trades) > 5:
+            events.append(f"{len(trades)} swap transactions executed")
+
+        return events[:5]  # Limit to top 5 events
+
+    def _build_summary_prompt(
+        self,
+        run_number: int,
+        metrics: Dict,
+        agent_performance: List[Dict],
+        action_distribution: Dict[str, int],
+        market_events: List[str]
+    ) -> str:
+        """Build the summary prompt for the LLM."""
+
+        top_agents = agent_performance[:3] if agent_performance else []
+        bottom_agents = agent_performance[-2:] if len(agent_performance) > 2 else []
+
+        prompt = f"""Generate a detailed summary of this DeFi agent simulation run.
+
+## Run {run_number} Summary
+
+### Overall Metrics
+- Gini Coefficient: {metrics.get('gini_coefficient', 0):.4f} (0=equal, 1=unequal)
+- Average Agent Profit: {metrics.get('avg_agent_profit', 0):.2f}
+- Cooperation Rate: {metrics.get('cooperation_rate', 0):.1f}%
+- Pool Stability: {metrics.get('pool_stability', 0):.0f}
+
+### Agent Performance (ranked by profit)
+"""
+
+        for i, agent in enumerate(top_agents, 1):
+            prompt += f"{i}. {agent['name']}: {agent['profit']:+.2f} profit ({agent['strategy']})\n"
+
+        if bottom_agents and bottom_agents != top_agents:
+            prompt += "\nBottom performers:\n"
+            for agent in bottom_agents:
+                prompt += f"- {agent['name']}: {agent['profit']:+.2f} ({agent['strategy']})\n"
+
+        prompt += f"\n### Action Distribution\n"
+        for action_type, count in sorted(action_distribution.items(), key=lambda x: -x[1]):
+            prompt += f"- {action_type}: {count}\n"
+
+        if market_events:
+            prompt += "\n### Notable Market Events\n"
+            for event in market_events:
+                prompt += f"- {event}\n"
+
+        prompt += """
+### Analysis
+Write a 2-3 paragraph analysis covering:
+1. Overall market behavior and whether agents cooperated or competed
+2. Notable strategy patterns and their effectiveness
+3. Key insights about the DeFi market dynamics
+
+Keep the tone informative and analytical. Use markdown formatting for readability.
+"""
+
+        return prompt
+
+    def summarize_and_save(self, run_id: int) -> Dict:
+        """Generate summary and save to database."""
+        summary_text = self.generate_summary(run_id)
+
+        # Save to database
+        summary_data = SummaryData(run_id=run_id, summary_text=summary_text)
+        self.supabase.save_run_summary(summary_data)
+
+        return {
+            "run_id": run_id,
+            "summary": summary_text
+        }

frontend/src/App.jsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useRef } from 'react'
-import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer } from 'recharts'
+import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts'
 
 const getApiBase = () => {
   const url = import.meta.env.VITE_API_URL || ''
@@ -14,11 +14,17 @@ function App() {
   const [activeTab, setActiveTab] = useState('dashboard')
   const [terminalLogs, setTerminalLogs] = useState([])
   const [isTerminalConnected, setIsTerminalConnected] = useState(false)
+  const [summaries, setSummaries] = useState([])
+  const [agents, setAgents] = useState([])
+  const [selectedAgent, setSelectedAgent] = useState(null)
+  const [agentProfitData, setAgentProfitData] = useState([])
 
   useEffect(() => {
     fetchRuns()
     fetchTrends()
     fetchLatestRunForTerminal()
+    fetchSummaries()
+    fetchAgents()
   }, [])
 
   const fetchRuns = async () => {
@@ -45,6 +51,61 @@ function App() {
     }
   }
 
+  const fetchSummaries = async () => {
+    try {
+      const res = await fetch(`${API_BASE}/summaries`)
+      if (res.ok) {
+        const data = await res.json()
+        setSummaries(data.summaries || [])
+      }
+    } catch (e) {
+      console.error('Failed to fetch summaries:', e)
+    }
+  }
+
+  const fetchAgents = async () => {
+    try {
+      const res = await fetch(`${API_BASE}/agents`)
+      if (res.ok) {
+        const data = await res.json()
+        setAgents(data.agents || [])
+        if (data.agents?.length > 0) {
+          setSelectedAgent(data.agents[0])
+        }
+      }
+    } catch (e) {
+      console.error('Failed to fetch agents:', e)
+    }
+  }
+
+  const fetchAgentProfits = async (agentName) => {
+    if (!agentName) return
+    try {
+      const res = await fetch(`${API_BASE}/agents/${agentName}/profits`)
+      if (res.ok) {
+        const data = await res.json()
+        // Group by run to show profit trajectory
+        const grouped = {}
+        data.data?.forEach(item => {
+          const runKey = `Run ${item.run}`
+          if (!grouped[runKey]) {
+            grouped[runKey] = { run: item.run, name: runKey }
+          }
+          grouped[runKey].profit = item.profit
+        })
+        setAgentProfitData(Object.values(grouped))
+      }
+    } catch (e) {
+      console.error('Failed to fetch agent profits:', e)
+    }
+  }
+
+  useEffect(() => {
+    if (selectedAgent) {
+      fetchAgentProfits(selectedAgent)
+    }
+  }, [selectedAgent])
+
   const fetchLatestRunForTerminal = async () => {
     try {
       const res = await fetch(`${API_BASE}/runs`)
@@ -148,6 +209,16 @@ function App() {
         >
           Dashboard
         </button>
+        <button
+          onClick={() => setActiveTab('summaries')}
+          className={`pb-3 px-4 text-sm font-medium border-b-2 transition-colors ${
+            activeTab === 'summaries'
+              ? 'border-green-500 text-white'
+              : 'border-transparent text-slate-400 hover:text-white'
+          }`}
+        >
+          Summaries
+        </button>
         <button
           onClick={() => setActiveTab('terminal')}
           className={`pb-3 px-4 text-sm font-medium border-b-2 transition-colors ${
@@ -309,6 +380,78 @@ function App() {
               </section>
             )}
           </>
+        ) : activeTab === 'summaries' ? (
+          /* Summaries Tab */
+          <div className="space-y-8">
+            {/* Agent Profit Chart */}
+            <section className="bg-slate-800 border-slate-700 rounded-lg border p-6">
+              <div className="flex justify-between items-center mb-4">
+                <h2 className="text-lg font-medium text-white">Agent Profit Over Time</h2>
+                <select
+                  value={selectedAgent || ''}
+                  onChange={(e) => setSelectedAgent(e.target.value)}
+                  className="px-4 py-2 rounded bg-slate-700 text-white border border-slate-600"
+                >
+                  {agents.map(agent => (
+                    <option key={agent} value={agent}>{agent}</option>
+                  ))}
+                </select>
+              </div>
+              <div className="h-[300px]">
+                <ResponsiveContainer width="100%" height="100%">
+                  <LineChart data={agentProfitData}>
+                    <CartesianGrid strokeDasharray="3 3" stroke="#334155" />
+                    <XAxis dataKey="name" stroke="#94a3b8" />
+                    <YAxis stroke="#94a3b8" />
+                    <Tooltip
+                      contentStyle={{ backgroundColor: '#1e293b', border: '1px solid #334155' }}
+                      labelStyle={{ color: '#fff' }}
+                    />
+                    <Line
+                      type="monotone"
+                      dataKey="profit"
+                      stroke="#22c55e"
+                      strokeWidth={2}
+                      dot={{ fill: '#22c55e' }}
+                      name="Profit"
+                    />
+                  </LineChart>
+                </ResponsiveContainer>
+              </div>
+            </section>
+
+            {/* Run Summaries */}
+            <section className="bg-slate-800 border-slate-700 rounded-lg border p-6">
+              <div className="flex justify-between items-center mb-4">
+                <h2 className="text-lg font-medium text-white">Run Summaries</h2>
+                <button
+                  onClick={() => fetchSummaries()}
+                  className="px-4 py-2 rounded bg-slate-700 text-white hover:bg-slate-600 text-sm"
+                >
+                  Refresh
+                </button>
+              </div>
+              {summaries.length === 0 ? (
+                <p className="text-slate-400">No summaries yet. Summaries are generated after each run.</p>
+              ) : (
+                <div className="space-y-6">
+                  {summaries.map((summary) => (
+                    <div key={summary.id} className="border-b border-slate-700 pb-6 last:border-0 last:pb-0">
+                      <div className="flex justify-between items-start mb-2">
+                        <h3 className="text-white font-medium">Run {summary.run_id}</h3>
+                        <span className="text-sm text-slate-500">
+                          {new Date(summary.created_at).toLocaleString()}
+                        </span>
+                      </div>
+                      <div className="text-slate-300 text-sm whitespace-pre-wrap">
+                        {summary.summary_text}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              )}
+            </section>
+          </div>
         ) : (
           /* Terminal Tab - Retro Style */
           <div className="bg-slate-800 border-slate-700 rounded-lg border p-6">

supabase/migrations/001_add_run_summaries.sql

@@ -0,0 +1,23 @@
+-- Migration: Add run_summaries table
+-- Run this in Supabase SQL Editor
+
+CREATE TABLE IF NOT EXISTS run_summaries (
+    id BIGSERIAL PRIMARY KEY,
+    run_id BIGINT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+    summary_text TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Index for fast lookups
+CREATE INDEX IF NOT EXISTS idx_run_summaries_run_id ON run_summaries(run_id);
+
+-- Enable RLS (Row Level Security)
+ALTER TABLE run_summaries ENABLE ROW LEVEL SECURITY;
+
+-- Policy to allow read access
+CREATE POLICY IF NOT EXISTS "Allow public read access" ON run_summaries
+    FOR SELECT USING (true);
+
+-- Policy to allow insert access (for authenticated users)
+CREATE POLICY IF NOT EXISTS "Allow authenticated insert" ON run_summaries
+    FOR INSERT WITH CHECK (auth.role() = 'authenticated');

web/app.py

@@ -9,6 +9,7 @@ import json
 from api.supabase_client import SupabaseClient
 from core.simulation import Simulation
 from core.analyzer import Analyzer
+from core.summarizer import Summarizer
 
 app = FastAPI(
     title="DeFi Agents API",
@@ -218,6 +219,92 @@ def get_arms_race_analysis(run_id: int):
         raise HTTPException(status_code=500, detail=str(e))
 
 
+# ==================== Summary Endpoints ====================
+
+@app.get("/api/runs/{run_id}/summary")
+def get_run_summary(run_id: int):
+    """Get summary for a specific run."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        summary = supabase.get_run_summary(run_id)
+        if not summary:
+            return {"run_id": run_id, "summary": None, "message": "No summary generated yet"}
+        return summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/summaries")
+def get_all_summaries():
+    """Get all run summaries."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        summaries = supabase.get_all_summaries()
+        return {"summaries": summaries}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/runs/{run_id}/generate-summary")
+def generate_run_summary(run_id: int):
+    """Generate and save a summary for a run."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        summarizer = Summarizer(supabase=supabase)
+        result = summarizer.summarize_and_save(run_id)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== Agent Profit Endpoints ====================
+
+@app.get("/api/agents")
+def get_all_agents():
+    """Get all unique agent names."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        agents = supabase.get_all_agent_names()
+        return {"agents": agents}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/agents/{agent_name}/profits")
+def get_agent_profits(agent_name: str):
+    """Get profit history for an agent across all runs."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Supabase not configured")
+
+    try:
+        profits = supabase.get_agent_profits_all_runs(agent_name)
+
+        # Format for chart: [{run: 1, profit: 0, turn: 0}, ...]
+        chart_data = []
+        for p in profits:
+            chart_data.append({
+                "run": p["run_id"],
+                "turn": p["turn"],
+                "profit": p["profit"],
+                "strategy": p.get("strategy", "unknown")
+            })
+
+        return {
+            "agent_name": agent_name,
+            "data": chart_data
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 def run_server():
     """Run the FastAPI server."""
     import uvicorn