feat: backend

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY . .
+
+# Create data directory for SQLite
+RUN mkdir -p /app/data
+
+# HuggingFace Spaces uses port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,30 @@
+---
+title: CryptoAgentBench API
+emoji: 📈
+colorFrom: indigo
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# CryptoAgentBench API
+
+Benchmarks open-source LLMs as crypto trading agents.
+
+## Endpoints
+
+- `GET /` — health check
+- `GET /models` — list available free-tier LLMs
+- `GET /benchmarks` — describe A/B/C benchmarks
+- `POST /backtest` — launch a backtest run
+- `GET /runs/{run_id}` — get run details + equity curve
+- `GET /runs/{run_id}/decisions` — get decision log
+- `GET /leaderboard` — all completed runs sorted by date
+
+## Environment Variables
+
+Set in HuggingFace Space Secrets:
+- `OPENROUTER_API_KEY` — required
+- `CRYPTOPANIC_API_KEY` — optional (news)
+- `CRYPTOCOMPARE_API_KEY` — optional (news fallback)

agents/analysts.py

@@ -0,0 +1,72 @@
+from agents.base import Agent
+from llm.prompts import (
+    TECHNICAL_ANALYST_SYSTEM,
+    NEWS_ANALYST_SYSTEM,
+    SENTIMENT_ANALYST_SYSTEM,
+    build_technical_analyst_prompt,
+    build_news_analyst_prompt,
+    build_sentiment_analyst_prompt,
+)
+
+
+class TechnicalAnalyst(Agent):
+    def __init__(self, llm_client):
+        super().__init__("TechnicalAnalyst", TECHNICAL_ANALYST_SYSTEM, llm_client)
+
+    def build_prompt(self, context: dict) -> str:
+        return build_technical_analyst_prompt(context)
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        signal = result.get("signal", "NEUTRAL").upper()
+        if signal not in ("BULLISH", "BEARISH", "NEUTRAL"):
+            signal = "NEUTRAL"
+        return {
+            "signal": signal,
+            "strength": float(result.get("strength", 0.5)),
+            "key_levels": result.get("key_levels", {}),
+            "summary": str(result.get("summary", "")),
+        }
+
+
+class NewsAnalyst(Agent):
+    def __init__(self, llm_client):
+        super().__init__("NewsAnalyst", NEWS_ANALYST_SYSTEM, llm_client)
+
+    def build_prompt(self, context: dict) -> str:
+        return build_news_analyst_prompt(
+            context.get("news", []),
+            context.get("asset", "BTC/USDT"),
+        )
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        sentiment = result.get("sentiment", "NEUTRAL").upper()
+        if sentiment not in ("POSITIVE", "NEGATIVE", "NEUTRAL"):
+            sentiment = "NEUTRAL"
+        return {
+            "sentiment": sentiment,
+            "score": float(result.get("score", 0.0)),
+            "key_themes": result.get("key_themes", []),
+            "summary": str(result.get("summary", "")),
+        }
+
+
+class SentimentAnalyst(Agent):
+    def __init__(self, llm_client):
+        super().__init__("SentimentAnalyst", SENTIMENT_ANALYST_SYSTEM, llm_client)
+
+    def build_prompt(self, context: dict) -> str:
+        return build_sentiment_analyst_prompt(
+            context.get("onchain", {}),
+            context.get("asset", "BTC/USDT"),
+        )
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        return {
+            "sentiment": str(result.get("sentiment", "NEUTRAL")),
+            "score": float(result.get("score", 0.0)),
+            "funding_bias": str(result.get("funding_bias", "NEUTRAL")),
+            "summary": str(result.get("summary", "")),
+        }

agents/base.py

@@ -0,0 +1,49 @@
+import json
+import re
+import logging
+from llm.openrouter import OpenRouterClient
+
+logger = logging.getLogger(__name__)
+
+FALLBACK_DECISION = {"action": "HOLD", "size": 0.0, "confidence": 0.0, "reason": "Parse error — defaulting to HOLD"}
+
+
+class Agent:
+    def __init__(self, role: str, system_prompt: str, llm_client: OpenRouterClient):
+        self.role = role
+        self.system_prompt = system_prompt
+        self.llm = llm_client
+
+    def run(self, context: dict) -> dict:
+        prompt = self.build_prompt(context)
+        raw = self.llm.call(self.system_prompt, prompt)
+        return self.parse(raw)
+
+    def build_prompt(self, context: dict) -> str:
+        raise NotImplementedError
+
+    def parse(self, raw: str) -> dict:
+        """Robust JSON parsing: strip markdown fences, regex fallback."""
+        if not raw:
+            return FALLBACK_DECISION.copy()
+
+        # Strip markdown code fences
+        cleaned = re.sub(r"```(?:json)?\s*", "", raw).strip()
+        cleaned = re.sub(r"```\s*$", "", cleaned).strip()
+
+        # Try direct parse
+        try:
+            return json.loads(cleaned)
+        except json.JSONDecodeError:
+            pass
+
+        # Try to extract first JSON object
+        match = re.search(r"\{[^{}]*\}", cleaned, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                pass
+
+        logger.warning(f"[{self.role}] Failed to parse response: {raw[:200]}")
+        return FALLBACK_DECISION.copy()

agents/pipeline.py

@@ -0,0 +1,130 @@
+import logging
+from agents.trader import Trader
+from agents.analysts import TechnicalAnalyst, NewsAnalyst, SentimentAnalyst
+from agents.researcher import Researcher
+from agents.risk_manager import RiskManager
+from llm.openrouter import OpenRouterClient
+
+logger = logging.getLogger(__name__)
+
+
+class SingleAgentPipeline:
+    """Benchmark A: single Trader agent with price + indicators."""
+
+    def __init__(self, trader: Trader):
+        self.trader = trader
+
+    def decide(self, market_data: dict) -> dict:
+        decision = self.trader.run(market_data)
+        return {
+            "decision": decision,
+            "agent_outputs": {"trader": decision},
+        }
+
+
+class SimplePipeline:
+    """Benchmark B: TechnicalAnalyst + NewsAnalyst -> Trader."""
+
+    def __init__(self, analysts: list, trader: Trader):
+        self.technical = next(a for a in analysts if isinstance(a, TechnicalAnalyst))
+        self.news = next(a for a in analysts if isinstance(a, NewsAnalyst))
+        self.trader = trader
+
+    def decide(self, market_data: dict) -> dict:
+        tech_analysis = self.technical.run(market_data)
+        news_analysis = self.news.run(market_data)
+
+        trader_context = {
+            **market_data,
+            "tech_analysis": tech_analysis,
+            "news_analysis": news_analysis,
+        }
+        decision = self.trader.run(trader_context)
+
+        return {
+            "decision": decision,
+            "agent_outputs": {
+                "technical_analyst": tech_analysis,
+                "news_analyst": news_analysis,
+                "trader": decision,
+            },
+        }
+
+
+class FullPipeline:
+    """Benchmark C: Technical + Sentiment + News -> Researcher -> RiskManager -> Trader."""
+
+    def __init__(self, analysts: list, researcher: Researcher, risk_manager: RiskManager, trader: Trader):
+        self.technical = next(a for a in analysts if isinstance(a, TechnicalAnalyst))
+        self.sentiment = next(a for a in analysts if isinstance(a, SentimentAnalyst))
+        self.news = next(a for a in analysts if isinstance(a, NewsAnalyst))
+        self.researcher = researcher
+        self.risk_manager = risk_manager
+        self.trader = trader
+
+    def decide(self, market_data: dict) -> dict:
+        # Phase 1: analysts
+        tech_analysis = self.technical.run(market_data)
+        news_analysis = self.news.run(market_data)
+        sentiment_analysis = self.sentiment.run(market_data)
+
+        # Phase 2: researcher bull/bear debate
+        research_context = {
+            **market_data,
+            "tech_analysis": tech_analysis,
+            "news_analysis": news_analysis,
+            "sentiment_analysis": sentiment_analysis,
+        }
+        research = self.researcher.run(research_context)
+
+        # Phase 3: risk manager
+        portfolio = market_data.get("portfolio", {})
+        risk_context = {
+            "recommendation": research,
+            "portfolio": portfolio,
+        }
+        risk_decision = self.risk_manager.run(risk_context)
+
+        # Phase 4: final trader decision
+        trader_context = {
+            **market_data,
+            "research": research,
+            "risk_decision": risk_decision,
+        }
+        decision = self.trader.run(trader_context)
+
+        return {
+            "decision": decision,
+            "agent_outputs": {
+                "technical_analyst": tech_analysis,
+                "news_analyst": news_analysis,
+                "sentiment_analyst": sentiment_analysis,
+                "researcher": research,
+                "risk_manager": risk_decision,
+                "trader": decision,
+            },
+        }
+
+
+def build_pipeline(benchmark: str, model: str):
+    """Factory: build the correct pipeline for benchmark A/B/C."""
+    llm = OpenRouterClient(model=model)
+
+    if benchmark == "A":
+        return SingleAgentPipeline(trader=Trader(llm, benchmark="A"))
+
+    if benchmark == "B":
+        return SimplePipeline(
+            analysts=[TechnicalAnalyst(llm), NewsAnalyst(llm)],
+            trader=Trader(llm, benchmark="B"),
+        )
+
+    if benchmark == "C":
+        return FullPipeline(
+            analysts=[TechnicalAnalyst(llm), SentimentAnalyst(llm), NewsAnalyst(llm)],
+            researcher=Researcher(llm),
+            risk_manager=RiskManager(llm),
+            trader=Trader(llm, benchmark="C"),
+        )
+
+    raise ValueError(f"Unknown benchmark: {benchmark}")

agents/researcher.py

@@ -0,0 +1,28 @@
+from agents.base import Agent
+from llm.prompts import RESEARCHER_SYSTEM, build_researcher_prompt
+
+
+class Researcher(Agent):
+    def __init__(self, llm_client):
+        super().__init__("Researcher", RESEARCHER_SYSTEM, llm_client)
+
+    def build_prompt(self, context: dict) -> str:
+        return build_researcher_prompt(
+            context.get("tech_analysis", {}),
+            context.get("news_analysis", {}),
+            context.get("sentiment_analysis", {}),
+            context.get("asset", "BTC/USDT"),
+        )
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        verdict = result.get("verdict", "NEUTRAL").upper()
+        if verdict not in ("BULLISH", "BEARISH", "NEUTRAL"):
+            verdict = "NEUTRAL"
+        return {
+            "verdict": verdict,
+            "conviction": float(result.get("conviction", 0.5)),
+            "bull_points": result.get("bull_points", []),
+            "bear_points": result.get("bear_points", []),
+            "synthesis": str(result.get("synthesis", "")),
+        }

agents/risk_manager.py

@@ -0,0 +1,25 @@
+from agents.base import Agent
+from llm.prompts import RISK_MANAGER_SYSTEM, build_risk_manager_prompt
+
+
+class RiskManager(Agent):
+    def __init__(self, llm_client):
+        super().__init__("RiskManager", RISK_MANAGER_SYSTEM, llm_client)
+
+    def build_prompt(self, context: dict) -> str:
+        return build_risk_manager_prompt(
+            context.get("recommendation", {}),
+            context.get("portfolio", {}),
+        )
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        action = result.get("adjusted_action", "HOLD").upper()
+        if action not in ("BUY", "SELL", "HOLD"):
+            action = "HOLD"
+        return {
+            "approved": bool(result.get("approved", True)),
+            "adjusted_action": action,
+            "adjusted_size": float(result.get("adjusted_size", 0.5)),
+            "risk_note": str(result.get("risk_note", "")),
+        }

agents/trader.py

@@ -0,0 +1,51 @@
+from agents.base import Agent, FALLBACK_DECISION
+from llm.prompts import (
+    TRADER_SYSTEM,
+    build_trader_prompt_A,
+    build_trader_prompt_B,
+    build_trader_prompt_C,
+)
+
+
+class Trader(Agent):
+    def __init__(self, llm_client, benchmark: str = "A"):
+        super().__init__("Trader", TRADER_SYSTEM, llm_client)
+        self.benchmark = benchmark
+
+    def build_prompt(self, context: dict) -> str:
+        if self.benchmark == "A":
+            return build_trader_prompt_A(context)
+        if self.benchmark == "B":
+            return build_trader_prompt_B(
+                context.get("tech_analysis", {}),
+                context.get("news_analysis", {}),
+                context.get("portfolio", {}),
+                context.get("asset", "BTC/USDT"),
+                context.get("current_price", 0),
+            )
+        if self.benchmark == "C":
+            return build_trader_prompt_C(
+                context.get("research", {}),
+                context.get("risk_decision", {}),
+                context.get("portfolio", {}),
+                context.get("asset", "BTC/USDT"),
+                context.get("current_price", 0),
+            )
+        return build_trader_prompt_A(context)
+
+    def parse(self, raw: str) -> dict:
+        result = super().parse(raw)
+        # Validate and normalize
+        action = result.get("action", "HOLD").upper()
+        if action not in ("BUY", "SELL", "HOLD"):
+            action = "HOLD"
+        size = float(result.get("size", 0.5))
+        size = max(0.0, min(1.0, size))
+        confidence = float(result.get("confidence", 0.5))
+        confidence = max(0.0, min(1.0, confidence))
+        return {
+            "action": action,
+            "size": size,
+            "confidence": confidence,
+            "reason": str(result.get("reason", "")),
+        }

app.py

@@ -0,0 +1,190 @@
+import logging
+import sys
+import os
+from contextlib import asynccontextmanager
+from datetime import date
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from fastapi import FastAPI, BackgroundTasks, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from config import BENCHMARKS, FREE_MODELS, ASSETS
+from db.store import init_db, create_run, complete_run, fail_run, get_run, get_leaderboard, get_decisions
+from backtest.runner import run_backtest
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s — %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    init_db()
+    logger.info("CryptoAgentBench API started")
+    yield
+
+
+app = FastAPI(
+    title="CryptoAgentBench API",
+    description="Benchmark open-source LLMs as crypto trading agents",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+class BacktestRequest(BaseModel):
+    benchmark: str = Field(..., description="A, B, or C")
+    model: str = Field(default="meta-llama/llama-3.3-70b-instruct:free")
+    asset: str = Field(default="BTC/USDT")
+    start_date: str = Field(default="2024-01-01", description="YYYY-MM-DD")
+    end_date: str = Field(default="2024-06-30", description="YYYY-MM-DD")
+
+    def validate_fields(self):
+        if self.benchmark not in BENCHMARKS:
+            raise ValueError(f"benchmark must be one of {BENCHMARKS}")
+        if self.asset not in ASSETS:
+            raise ValueError(f"asset must be one of {ASSETS}")
+
+
+# ── Background task ───────────────────────────────────────────────────────────
+
+def _run_backtest_task(run_id: str, req: BacktestRequest):
+    try:
+        result = run_backtest(
+            benchmark=req.benchmark,
+            model=req.model,
+            asset=req.asset,
+            start_date=req.start_date,
+            end_date=req.end_date,
+        )
+        complete_run(run_id, result)
+        logger.info(f"Run {run_id} completed. CR={result['metrics'].get('cumulative_return')}")
+    except Exception as e:
+        logger.error(f"Run {run_id} failed: {e}", exc_info=True)
+        fail_run(run_id, str(e))
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+
+@app.get("/")
+def health():
+    return {
+        "status": "ok",
+        "service": "CryptoAgentBench API",
+        "version": "1.0.0",
+        "date": date.today().isoformat(),
+    }
+
+
+@app.get("/models")
+def list_models():
+    return {
+        "models": FREE_MODELS,
+        "note": "All models are free-tier via OpenRouter",
+    }
+
+
+@app.get("/benchmarks")
+def list_benchmarks():
+    return {
+        "benchmarks": {
+            "A": {
+                "name": "Baseline",
+                "description": "Single agent: LLM sees price + indicators directly",
+                "agents": ["Trader"],
+                "data": ["OHLCV", "Technical Indicators"],
+            },
+            "B": {
+                "name": "Intermediate",
+                "description": "Technical Analyst + News Analyst -> Trader",
+                "agents": ["TechnicalAnalyst", "NewsAnalyst", "Trader"],
+                "data": ["OHLCV", "Technical Indicators", "News"],
+            },
+            "C": {
+                "name": "Full Multi-Agent",
+                "description": "Technical + Sentiment + News -> Researcher (bull/bear debate) -> Risk Manager -> Trader",
+                "agents": ["TechnicalAnalyst", "SentimentAnalyst", "NewsAnalyst", "Researcher", "RiskManager", "Trader"],
+                "data": ["OHLCV", "Technical Indicators", "News", "Fear & Greed", "Funding Rates"],
+            },
+        }
+    }
+
+
+@app.post("/backtest")
+def start_backtest(req: BacktestRequest, background_tasks: BackgroundTasks):
+    try:
+        req.validate_fields()
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    run_id = create_run(req.benchmark, req.model, req.asset, req.start_date, req.end_date)
+    background_tasks.add_task(_run_backtest_task, run_id, req)
+
+    return {
+        "run_id": run_id,
+        "status": "running",
+        "message": "Backtest started. Poll /runs/{run_id} for results.",
+    }
+
+
+@app.get("/runs/{run_id}")
+def get_run_detail(run_id: str):
+    run = get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    # Don't embed all decisions in the detail view
+    run_out = {k: v for k, v in run.items() if k not in ("equity_curve", "hodl_curve")}
+    run_out["equity_curve"] = run.get("equity_curve", [])
+    run_out["hodl_curve"] = run.get("hodl_curve", [])
+    return run_out
+
+
+@app.get("/runs/{run_id}/decisions")
+def get_run_decisions(run_id: str):
+    run = get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    decisions = get_decisions(run_id)
+    return {"run_id": run_id, "decisions": decisions}
+
+
+@app.get("/leaderboard")
+def leaderboard():
+    runs = get_leaderboard()
+    board = []
+    for r in runs:
+        metrics = r.get("metrics", {}) or {}
+        board.append({
+            "run_id": r["id"],
+            "benchmark": r["benchmark"],
+            "model": r["model"],
+            "asset": r["asset"],
+            "start_date": r.get("start_date"),
+            "end_date": r.get("end_date"),
+            "cumulative_return": metrics.get("cumulative_return"),
+            "sharpe_ratio": metrics.get("sharpe_ratio"),
+            "sortino_ratio": metrics.get("sortino_ratio"),
+            "max_drawdown": metrics.get("max_drawdown"),
+            "win_rate": metrics.get("win_rate"),
+            "num_trades": metrics.get("num_trades"),
+            "hodl_return": metrics.get("hodl_return"),
+            "alpha": metrics.get("alpha"),
+            "final_value": metrics.get("final_value"),
+            "completed_at": r.get("completed_at"),
+        })
+    return {"leaderboard": board, "total": len(board)}

backtest/portfolio.py

@@ -0,0 +1,154 @@
+import numpy as np
+from config import INITIAL_CAPITAL, TRADE_FEE
+
+
+class Portfolio:
+    def __init__(self, initial_capital: float = INITIAL_CAPITAL):
+        self.initial_capital = initial_capital
+        self.cash = initial_capital
+        self.position = 0.0  # units of asset held
+        self.trades = []
+        self.equity_history = []  # [{date, value, price, action}]
+        self.peak_value = initial_capital
+
+    def apply_decision(self, decision: dict, price: float, date: str):
+        action = decision.get("action", "HOLD")
+        size = float(decision.get("size", 0.5))
+        size = max(0.0, min(1.0, size))
+
+        trade_executed = False
+        trade_value = 0.0
+
+        if action == "BUY" and self.cash > 0:
+            spend = self.cash * size
+            fee = spend * TRADE_FEE
+            net_spend = spend - fee
+            units = net_spend / price
+            self.position += units
+            self.cash -= spend
+            trade_executed = True
+            trade_value = spend
+            self.trades.append({
+                "date": date,
+                "action": "BUY",
+                "price": price,
+                "units": units,
+                "value": spend,
+                "fee": fee,
+            })
+
+        elif action == "SELL" and self.position > 0:
+            sell_units = self.position * size
+            gross = sell_units * price
+            fee = gross * TRADE_FEE
+            net = gross - fee
+            self.position -= sell_units
+            self.cash += net
+            trade_executed = True
+            trade_value = gross
+            self.trades.append({
+                "date": date,
+                "action": "SELL",
+                "price": price,
+                "units": sell_units,
+                "value": gross,
+                "fee": fee,
+            })
+
+        total_value = self.cash + self.position * price
+        self.peak_value = max(self.peak_value, total_value)
+
+        self.equity_history.append({
+            "date": date,
+            "value": round(total_value, 2),
+            "cash": round(self.cash, 2),
+            "position": self.position,
+            "price": price,
+            "action": action,
+            "trade_executed": trade_executed,
+            "trade_value": round(trade_value, 2),
+        })
+
+    def current_value(self, price: float) -> float:
+        return self.cash + self.position * price
+
+    def drawdown(self, price: float) -> float:
+        current = self.current_value(price)
+        if self.peak_value == 0:
+            return 0.0
+        return (self.peak_value - current) / self.peak_value
+
+    def snapshot(self, price: float) -> dict:
+        total = self.current_value(price)
+        return {
+            "cash": round(self.cash, 2),
+            "position": self.position,
+            "total_value": round(total, 2),
+            "drawdown": round(self.drawdown(price), 4),
+        }
+
+
+def compute_metrics(equity_history: list, initial_capital: float, hodl_final: float) -> dict:
+    if not equity_history:
+        return {}
+
+    values = [e["value"] for e in equity_history]
+    dates = [e["date"] for e in equity_history]
+
+    # Daily returns
+    returns = []
+    for i in range(1, len(values)):
+        r = (values[i] - values[i - 1]) / values[i - 1] if values[i - 1] != 0 else 0
+        returns.append(r)
+
+    returns_arr = np.array(returns)
+    final_value = values[-1]
+
+    # Cumulative Return
+    cumulative_return = (final_value - initial_capital) / initial_capital
+
+    # Sharpe Ratio (annualized, risk-free = 0)
+    if len(returns_arr) > 1 and returns_arr.std() > 0:
+        sharpe = (returns_arr.mean() / returns_arr.std()) * np.sqrt(252)
+    else:
+        sharpe = 0.0
+
+    # Sortino Ratio
+    downside = returns_arr[returns_arr < 0]
+    if len(downside) > 0 and downside.std() > 0:
+        sortino = (returns_arr.mean() / downside.std()) * np.sqrt(252)
+    else:
+        sortino = 0.0
+
+    # Max Drawdown
+    peak = initial_capital
+    max_dd = 0.0
+    for v in values:
+        if v > peak:
+            peak = v
+        dd = (peak - v) / peak if peak > 0 else 0
+        max_dd = max(max_dd, dd)
+
+    # Win Rate
+    winning_trades = sum(1 for e in equity_history if e.get("trade_executed") and e.get("action") == "BUY")
+    num_trades = sum(1 for e in equity_history if e.get("trade_executed"))
+    win_rate = winning_trades / num_trades if num_trades > 0 else 0.0
+
+    # vs HODL
+    hodl_return = (hodl_final - initial_capital) / initial_capital
+    alpha = cumulative_return - hodl_return
+
+    return {
+        "cumulative_return": round(cumulative_return, 4),
+        "sharpe_ratio": round(sharpe, 4),
+        "sortino_ratio": round(sortino, 4),
+        "max_drawdown": round(max_dd, 4),
+        "win_rate": round(win_rate, 4),
+        "num_trades": num_trades,
+        "final_value": round(final_value, 2),
+        "hodl_return": round(hodl_return, 4),
+        "alpha": round(alpha, 4),
+        "start_date": dates[0] if dates else "",
+        "end_date": dates[-1] if dates else "",
+        "num_days": len(values),
+    }

backtest/runner.py

@@ -0,0 +1,142 @@
+import logging
+from datetime import datetime
+from data.prices import fetch_ohlcv, ohlcv_to_records
+from data.indicators import compute_indicators, get_latest_indicators
+from data.news import fetch_news
+from data.onchain import fetch_onchain_data
+from backtest.portfolio import Portfolio, compute_metrics
+from agents.pipeline import build_pipeline
+
+logger = logging.getLogger(__name__)
+
+
+def run_backtest(
+    benchmark: str,
+    model: str,
+    asset: str,
+    start_date: str,
+    end_date: str,
+    progress_callback=None,
+) -> dict:
+    """
+    Full backtest loop. Returns dict with metrics, equity_curve, decisions, hodl_curve.
+    """
+    logger.info(f"Starting backtest: benchmark={benchmark} model={model} asset={asset} {start_date}->{end_date}")
+
+    # Fetch and prepare price data
+    df_raw = fetch_ohlcv(asset, start_date, end_date)
+    df = compute_indicators(df_raw)
+
+    if df.empty or len(df) < 2:
+        raise ValueError(f"Insufficient data for {asset} from {start_date} to {end_date}")
+
+    ohlcv_records = ohlcv_to_records(df)
+
+    # Portfolio for agent strategy
+    portfolio = Portfolio()
+
+    # HODL portfolio (buy on day 1, hold)
+    hodl_portfolio = Portfolio()
+    first_price = float(df.iloc[0]["close"])
+    hodl_portfolio.apply_decision({"action": "BUY", "size": 1.0}, first_price, str(df.iloc[0]["date"]))
+
+    decisions_log = []
+    pipeline = build_pipeline(benchmark, model)
+
+    total_days = len(df)
+
+    for i, row in df.iterrows():
+        date = str(row["date"])
+        price = float(row["close"])
+
+        # Build market_data context (data available up to this day)
+        recent_records = ohlcv_records[: i + 1]
+        indicators = get_latest_indicators(df.iloc[: i + 1])
+
+        portfolio_snapshot = portfolio.snapshot(price)
+
+        market_data = {
+            "asset": asset,
+            "current_price": price,
+            "date": date,
+            "recent_ohlcv": recent_records[-30:],  # last 30 days
+            "indicators": indicators,
+            "portfolio": portfolio_snapshot,
+        }
+
+        # Add news/onchain for benchmarks B and C (only in live-style; skip for backtest speed)
+        if benchmark in ("B", "C"):
+            try:
+                news = fetch_news(asset, date=date, limit=5)
+                market_data["news"] = news
+            except Exception as e:
+                logger.warning(f"News fetch failed for {date}: {e}")
+                market_data["news"] = []
+
+        if benchmark == "C":
+            try:
+                onchain = fetch_onchain_data(asset)
+                market_data["onchain"] = onchain
+            except Exception as e:
+                logger.warning(f"On-chain fetch failed for {date}: {e}")
+                market_data["onchain"] = {}
+
+        # Get decision from pipeline
+        try:
+            result = pipeline.decide(market_data)
+            decision = result["decision"]
+            agent_outputs = result.get("agent_outputs", {})
+        except Exception as e:
+            logger.error(f"Pipeline error on {date}: {e}")
+            decision = {"action": "HOLD", "size": 0.0, "confidence": 0.0, "reason": f"Error: {e}"}
+            agent_outputs = {}
+
+        # Apply to portfolio
+        portfolio.apply_decision(decision, price, date)
+
+        # Update HODL
+        hodl_portfolio.equity_history.append({
+            "date": date,
+            "value": round(hodl_portfolio.cash + hodl_portfolio.position * price, 2),
+            "price": price,
+            "action": "HOLD",
+            "trade_executed": False,
+            "trade_value": 0.0,
+            "cash": hodl_portfolio.cash,
+            "position": hodl_portfolio.position,
+        })
+
+        decisions_log.append({
+            "date": date,
+            "price": price,
+            "action": decision.get("action"),
+            "size": decision.get("size"),
+            "confidence": decision.get("confidence"),
+            "reason": decision.get("reason"),
+            "agent_outputs": agent_outputs,
+            "portfolio_value": portfolio_snapshot["total_value"],
+        })
+
+        if progress_callback:
+            progress_callback(i + 1, total_days)
+
+        logger.debug(f"{date} | {asset} | {decision.get('action')} | price={price:.2f} | portfolio={portfolio_snapshot['total_value']:.2f}")
+
+    # Final metrics
+    hodl_final = hodl_portfolio.equity_history[-1]["value"] if hodl_portfolio.equity_history else portfolio.initial_capital
+    metrics = compute_metrics(portfolio.equity_history, portfolio.initial_capital, hodl_final)
+
+    hodl_curve = [{"date": e["date"], "value": e["value"]} for e in hodl_portfolio.equity_history]
+    equity_curve = [{"date": e["date"], "value": e["value"], "action": e.get("action", "HOLD")} for e in portfolio.equity_history]
+
+    return {
+        "benchmark": benchmark,
+        "model": model,
+        "asset": asset,
+        "start_date": start_date,
+        "end_date": end_date,
+        "metrics": metrics,
+        "equity_curve": equity_curve,
+        "hodl_curve": hodl_curve,
+        "decisions": decisions_log,
+    }

config.py

@@ -0,0 +1,35 @@
+import os
+
+# OpenRouter
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+# Free models on OpenRouter
+FREE_MODELS = [
+    "deepseek/deepseek-r1:free",
+    "meta-llama/llama-3.3-70b-instruct:free",
+    "qwen/qwen3-coder:free",
+]
+DEFAULT_MODEL = FREE_MODELS[1]
+
+# Supported assets
+ASSETS = ["BTC/USDT", "ETH/USDT"]
+ASSET_YFINANCE_MAP = {
+    "BTC/USDT": "BTC-USD",
+    "ETH/USDT": "ETH-USD",
+}
+
+# Benchmarks
+BENCHMARKS = ["A", "B", "C"]
+
+# Portfolio
+INITIAL_CAPITAL = 10_000.0
+TRADE_FEE = 0.001  # 0.1%
+
+# Rate limiting (OpenRouter free tier)
+MAX_REQUESTS_PER_MINUTE = 18  # conservative under 20
+LLM_TIMEOUT = 120
+LLM_MAX_RETRIES = 3
+
+# DB
+DB_PATH = os.getenv("DB_PATH", "/app/data/benchmark.db")

data/indicators.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import numpy as np
+
+
+def compute_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    """Add RSI, MA, MACD, Bollinger Bands to a OHLCV DataFrame."""
+    df = df.copy()
+    close = df["close"].astype(float)
+
+    # Moving averages
+    df["ma20"] = close.rolling(20).mean().round(2)
+    df["ma50"] = close.rolling(50).mean().round(2)
+
+    # RSI(14)
+    df["rsi"] = _rsi(close, 14).round(2)
+
+    # MACD (12,26,9)
+    ema12 = close.ewm(span=12, adjust=False).mean()
+    ema26 = close.ewm(span=26, adjust=False).mean()
+    df["macd"] = (ema12 - ema26).round(2)
+    df["macd_signal"] = df["macd"].ewm(span=9, adjust=False).mean().round(2)
+    df["macd_hist"] = (df["macd"] - df["macd_signal"]).round(2)
+
+    # Bollinger Bands (20, 2)
+    std20 = close.rolling(20).std()
+    df["bb_upper"] = (df["ma20"] + 2 * std20).round(2)
+    df["bb_lower"] = (df["ma20"] - 2 * std20).round(2)
+
+    return df
+
+
+def _rsi(series: pd.Series, period: int = 14) -> pd.Series:
+    delta = series.diff()
+    gain = delta.clip(lower=0)
+    loss = -delta.clip(upper=0)
+    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
+    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
+    rs = avg_gain / avg_loss.replace(0, np.nan)
+    return 100 - (100 / (1 + rs))
+
+
+def get_latest_indicators(df: pd.DataFrame) -> dict:
+    """Return the most recent indicator values as a dict."""
+    if df.empty:
+        return {}
+    row = df.iloc[-1]
+
+    def safe(val):
+        if pd.isna(val):
+            return None
+        return float(val)
+
+    return {
+        "rsi": safe(row.get("rsi")),
+        "ma20": safe(row.get("ma20")),
+        "ma50": safe(row.get("ma50")),
+        "macd": safe(row.get("macd")),
+        "macd_signal": safe(row.get("macd_signal")),
+        "macd_hist": safe(row.get("macd_hist")),
+        "bb_upper": safe(row.get("bb_upper")),
+        "bb_lower": safe(row.get("bb_lower")),
+    }

data/news.py

@@ -0,0 +1,67 @@
+import logging
+import os
+import requests
+
+logger = logging.getLogger(__name__)
+
+CRYPTOPANIC_API_KEY = os.getenv("CRYPTOPANIC_API_KEY", "")
+CRYPTOCOMPARE_API_KEY = os.getenv("CRYPTOCOMPARE_API_KEY", "")
+
+
+def fetch_news(asset: str, date: str = None, limit: int = 10) -> list:
+    """Fetch crypto news. Returns list of {title, url, published_at}."""
+    currency = asset.split("/")[0]  # BTC, ETH
+
+    # Try CryptoPanic first
+    if CRYPTOPANIC_API_KEY:
+        try:
+            return _fetch_cryptopanic(currency, limit)
+        except Exception as e:
+            logger.warning(f"CryptoPanic failed: {e}")
+
+    # Try CryptoCompare
+    try:
+        return _fetch_cryptocompare(currency, limit)
+    except Exception as e:
+        logger.warning(f"CryptoCompare failed: {e}")
+
+    return []
+
+
+def _fetch_cryptopanic(currency: str, limit: int) -> list:
+    url = "https://cryptopanic.com/api/v1/posts/"
+    params = {
+        "auth_token": CRYPTOPANIC_API_KEY,
+        "currencies": currency,
+        "kind": "news",
+        "limit": limit,
+    }
+    resp = requests.get(url, params=params, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+    results = []
+    for item in data.get("results", [])[:limit]:
+        results.append({
+            "title": item.get("title", ""),
+            "url": item.get("url", ""),
+            "published_at": item.get("published_at", ""),
+        })
+    return results
+
+
+def _fetch_cryptocompare(currency: str, limit: int) -> list:
+    url = "https://min-api.cryptocompare.com/data/v2/news/"
+    params = {"categories": currency, "lang": "EN", "limit": limit}
+    if CRYPTOCOMPARE_API_KEY:
+        params["api_key"] = CRYPTOCOMPARE_API_KEY
+    resp = requests.get(url, params=params, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+    results = []
+    for item in data.get("Data", [])[:limit]:
+        results.append({
+            "title": item.get("title", ""),
+            "url": item.get("url", ""),
+            "published_at": str(item.get("published_on", "")),
+        })
+    return results

data/onchain.py

@@ -0,0 +1,46 @@
+import logging
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_fear_greed() -> dict:
+    """Fetch Fear & Greed index from alternative.me (no API key needed)."""
+    try:
+        resp = requests.get("https://api.alternative.me/fng/?limit=1", timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        item = data["data"][0]
+        return {
+            "value": int(item["value"]),
+            "label": item["value_classification"],
+            "timestamp": item["timestamp"],
+        }
+    except Exception as e:
+        logger.warning(f"Fear & Greed fetch failed: {e}")
+        return {"value": 50, "label": "Neutral", "timestamp": ""}
+
+
+def fetch_funding_rate(asset: str) -> float | None:
+    """Fetch current funding rate from Binance public API."""
+    symbol_map = {"BTC/USDT": "BTCUSDT", "ETH/USDT": "ETHUSDT"}
+    symbol = symbol_map.get(asset, asset.replace("/", ""))
+    try:
+        url = "https://fapi.binance.com/fapi/v1/fundingRate"
+        params = {"symbol": symbol, "limit": 1}
+        resp = requests.get(url, params=params, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        if data:
+            return float(data[-1]["fundingRate"]) * 100  # as percentage
+    except Exception as e:
+        logger.warning(f"Funding rate fetch failed for {asset}: {e}")
+    return None
+
+
+def fetch_onchain_data(asset: str) -> dict:
+    """Aggregate all on-chain data for one asset."""
+    return {
+        "fear_greed": fetch_fear_greed(),
+        "funding_rate": fetch_funding_rate(asset),
+    }

data/prices.py

@@ -0,0 +1,81 @@
+import logging
+from datetime import datetime, timedelta
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_ohlcv(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    """Fetch OHLCV data. Tries ccxt first, falls back to yfinance."""
+    try:
+        return _fetch_ccxt(asset, start_date, end_date)
+    except Exception as e:
+        logger.warning(f"ccxt failed for {asset}: {e}, falling back to yfinance")
+        return _fetch_yfinance(asset, start_date, end_date)
+
+
+def _fetch_ccxt(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    import ccxt
+    exchange = ccxt.binance({"enableRateLimit": True})
+    since = int(datetime.strptime(start_date, "%Y-%m-%d").timestamp() * 1000)
+    limit = 1000
+
+    all_candles = []
+    current_since = since
+    end_ts = int(datetime.strptime(end_date, "%Y-%m-%d").timestamp() * 1000)
+
+    while current_since < end_ts:
+        candles = exchange.fetch_ohlcv(asset, "1d", since=current_since, limit=limit)
+        if not candles:
+            break
+        all_candles.extend(candles)
+        current_since = candles[-1][0] + 86400000
+        if len(candles) < limit:
+            break
+
+    if not all_candles:
+        raise ValueError(f"No data returned from ccxt for {asset}")
+
+    df = pd.DataFrame(all_candles, columns=["timestamp", "open", "high", "low", "close", "volume"])
+    df["date"] = pd.to_datetime(df["timestamp"], unit="ms").dt.date.astype(str)
+    df = df[(df["date"] >= start_date) & (df["date"] <= end_date)]
+    df = df.drop_duplicates("date").sort_values("date").reset_index(drop=True)
+    return df
+
+
+def _fetch_yfinance(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    import yfinance as yf
+    from config import ASSET_YFINANCE_MAP
+
+    ticker = ASSET_YFINANCE_MAP.get(asset, asset.replace("/", "-"))
+    # Add one day buffer because yfinance end is exclusive
+    end_dt = (datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)).strftime("%Y-%m-%d")
+    data = yf.download(ticker, start=start_date, end=end_dt, progress=False, auto_adjust=True)
+
+    if data.empty:
+        raise ValueError(f"No data returned from yfinance for {ticker}")
+
+    df = pd.DataFrame()
+    df["open"] = data["Open"].values.flatten()
+    df["high"] = data["High"].values.flatten()
+    df["low"] = data["Low"].values.flatten()
+    df["close"] = data["Close"].values.flatten()
+    df["volume"] = data["Volume"].values.flatten()
+    df["date"] = data.index.strftime("%Y-%m-%d")
+    df = df.sort_values("date").reset_index(drop=True)
+    return df
+
+
+def ohlcv_to_records(df: pd.DataFrame) -> list:
+    """Convert OHLCV DataFrame to list of dicts for prompts."""
+    records = []
+    for _, row in df.iterrows():
+        records.append({
+            "date": str(row["date"]),
+            "open": float(row["open"]),
+            "high": float(row["high"]),
+            "low": float(row["low"]),
+            "close": float(row["close"]),
+            "volume": float(row["volume"]),
+        })
+    return records

db/store.py

@@ -0,0 +1,155 @@
+import sqlite3
+import json
+import os
+import uuid
+import logging
+from datetime import datetime
+from config import DB_PATH
+
+logger = logging.getLogger(__name__)
+
+
+def _get_conn():
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db():
+    """Create tables if they don't exist."""
+    conn = _get_conn()
+    c = conn.cursor()
+    c.executescript("""
+        CREATE TABLE IF NOT EXISTS runs (
+            id TEXT PRIMARY KEY,
+            benchmark TEXT NOT NULL,
+            model TEXT NOT NULL,
+            asset TEXT NOT NULL,
+            start_date TEXT,
+            end_date TEXT,
+            status TEXT DEFAULT 'pending',
+            created_at TEXT,
+            completed_at TEXT,
+            metrics TEXT,
+            equity_curve TEXT,
+            hodl_curve TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS decisions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            run_id TEXT NOT NULL,
+            date TEXT,
+            price REAL,
+            action TEXT,
+            size REAL,
+            confidence REAL,
+            reason TEXT,
+            agent_outputs TEXT,
+            portfolio_value REAL,
+            FOREIGN KEY (run_id) REFERENCES runs(id)
+        );
+    """)
+    conn.commit()
+    conn.close()
+    logger.info(f"DB initialized at {DB_PATH}")
+
+
+def create_run(benchmark: str, model: str, asset: str, start_date: str, end_date: str) -> str:
+    run_id = str(uuid.uuid4())
+    conn = _get_conn()
+    conn.execute(
+        "INSERT INTO runs (id, benchmark, model, asset, start_date, end_date, status, created_at) VALUES (?,?,?,?,?,?,?,?)",
+        (run_id, benchmark, model, asset, start_date, end_date, "running", datetime.utcnow().isoformat()),
+    )
+    conn.commit()
+    conn.close()
+    return run_id
+
+
+def complete_run(run_id: str, result: dict):
+    metrics_json = json.dumps(result.get("metrics", {}))
+    equity_json = json.dumps(result.get("equity_curve", []))
+    hodl_json = json.dumps(result.get("hodl_curve", []))
+
+    conn = _get_conn()
+    conn.execute(
+        "UPDATE runs SET status=?, completed_at=?, metrics=?, equity_curve=?, hodl_curve=? WHERE id=?",
+        ("completed", datetime.utcnow().isoformat(), metrics_json, equity_json, hodl_json, run_id),
+    )
+
+    for d in result.get("decisions", []):
+        conn.execute(
+            "INSERT INTO decisions (run_id, date, price, action, size, confidence, reason, agent_outputs, portfolio_value) VALUES (?,?,?,?,?,?,?,?,?)",
+            (
+                run_id,
+                d.get("date"),
+                d.get("price"),
+                d.get("action"),
+                d.get("size"),
+                d.get("confidence"),
+                d.get("reason"),
+                json.dumps(d.get("agent_outputs", {})),
+                d.get("portfolio_value"),
+            ),
+        )
+
+    conn.commit()
+    conn.close()
+
+
+def fail_run(run_id: str, error: str):
+    conn = _get_conn()
+    conn.execute(
+        "UPDATE runs SET status=?, completed_at=?, metrics=? WHERE id=?",
+        ("failed", datetime.utcnow().isoformat(), json.dumps({"error": error}), run_id),
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_run(run_id: str) -> dict | None:
+    conn = _get_conn()
+    row = conn.execute("SELECT * FROM runs WHERE id=?", (run_id,)).fetchone()
+    conn.close()
+    if not row:
+        return None
+    return _row_to_run(row)
+
+
+def get_leaderboard() -> list:
+    conn = _get_conn()
+    rows = conn.execute(
+        "SELECT * FROM runs WHERE status='completed' ORDER BY created_at DESC"
+    ).fetchall()
+    conn.close()
+    return [_row_to_run(r) for r in rows]
+
+
+def get_decisions(run_id: str) -> list:
+    conn = _get_conn()
+    rows = conn.execute(
+        "SELECT * FROM decisions WHERE run_id=? ORDER BY date ASC", (run_id,)
+    ).fetchall()
+    conn.close()
+    result = []
+    for row in rows:
+        d = dict(row)
+        if d.get("agent_outputs"):
+            try:
+                d["agent_outputs"] = json.loads(d["agent_outputs"])
+            except Exception:
+                pass
+        result.append(d)
+    return result
+
+
+def _row_to_run(row) -> dict:
+    d = dict(row)
+    for field in ("metrics", "equity_curve", "hodl_curve"):
+        if d.get(field):
+            try:
+                d[field] = json.loads(d[field])
+            except Exception:
+                d[field] = {}
+    return d

live/daily_job.py

@@ -0,0 +1,147 @@
+"""
+Daily live trading job — run once per day via cron.
+Idempotent: skips a day already processed.
+Usage: python live/daily_job.py
+"""
+import logging
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime, date
+from data.prices import fetch_ohlcv
+from data.indicators import compute_indicators, get_latest_indicators
+from data.news import fetch_news
+from data.onchain import fetch_onchain_data
+from backtest.portfolio import Portfolio
+from agents.pipeline import build_pipeline
+from db.store import init_db, _get_conn
+from config import FREE_MODELS, ASSETS, BENCHMARKS
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+TODAY = date.today().isoformat()
+
+
+def _already_processed(benchmark: str, model: str, asset: str, day: str) -> bool:
+    conn = _get_conn()
+    row = conn.execute(
+        "SELECT id FROM decisions WHERE run_id IN (SELECT id FROM runs WHERE benchmark=? AND model=? AND asset=? AND status='live') AND date=?",
+        (benchmark, model, asset, day),
+    ).fetchone()
+    conn.close()
+    return row is not None
+
+
+def _get_or_create_live_run(benchmark: str, model: str, asset: str) -> str:
+    conn = _get_conn()
+    row = conn.execute(
+        "SELECT id FROM runs WHERE benchmark=? AND model=? AND asset=? AND status='live'",
+        (benchmark, model, asset),
+    ).fetchone()
+    if row:
+        run_id = row["id"]
+    else:
+        import uuid
+        run_id = str(uuid.uuid4())
+        from datetime import datetime
+        conn.execute(
+            "INSERT INTO runs (id, benchmark, model, asset, status, created_at) VALUES (?,?,?,?,?,?)",
+            (run_id, benchmark, model, asset, "live", datetime.utcnow().isoformat()),
+        )
+        conn.commit()
+    conn.close()
+    return run_id
+
+
+def run_daily():
+    init_db()
+    logger.info(f"Daily live job — {TODAY}")
+
+    # Look back 60 days for indicators
+    from datetime import datetime, timedelta
+    lookback_start = (datetime.strptime(TODAY, "%Y-%m-%d") - timedelta(days=60)).strftime("%Y-%m-%d")
+
+    for model in FREE_MODELS:
+        for benchmark in BENCHMARKS:
+            for asset in ASSETS:
+                logger.info(f"Processing {benchmark}/{model}/{asset}")
+
+                if _already_processed(benchmark, model, asset, TODAY):
+                    logger.info(f"Already processed {benchmark}/{model}/{asset}/{TODAY}, skipping")
+                    continue
+
+                try:
+                    df_raw = fetch_ohlcv(asset, lookback_start, TODAY)
+                    df = compute_indicators(df_raw)
+                    if df.empty:
+                        logger.warning(f"No data for {asset}")
+                        continue
+
+                    row = df.iloc[-1]
+                    price = float(row["close"])
+                    indicators = get_latest_indicators(df)
+
+                    run_id = _get_or_create_live_run(benchmark, model, asset)
+
+                    # Load portfolio state from DB
+                    conn = _get_conn()
+                    last_snap = conn.execute(
+                        "SELECT portfolio_value FROM decisions WHERE run_id=? ORDER BY date DESC LIMIT 1",
+                        (run_id,),
+                    ).fetchone()
+                    conn.close()
+
+                    from config import INITIAL_CAPITAL
+                    portfolio_value = last_snap["portfolio_value"] if last_snap else INITIAL_CAPITAL
+                    # Simplified snapshot (no persistent position tracking for now)
+                    portfolio_snapshot = {
+                        "cash": portfolio_value,
+                        "position": 0.0,
+                        "total_value": portfolio_value,
+                        "drawdown": 0.0,
+                    }
+
+                    from data.prices import ohlcv_to_records
+                    market_data = {
+                        "asset": asset,
+                        "current_price": price,
+                        "date": TODAY,
+                        "recent_ohlcv": ohlcv_to_records(df)[-30:],
+                        "indicators": indicators,
+                        "portfolio": portfolio_snapshot,
+                    }
+
+                    if benchmark in ("B", "C"):
+                        market_data["news"] = fetch_news(asset, limit=5)
+                    if benchmark == "C":
+                        market_data["onchain"] = fetch_onchain_data(asset)
+
+                    pipeline = build_pipeline(benchmark, model)
+                    result = pipeline.decide(market_data)
+                    decision = result["decision"]
+                    agent_outputs = result.get("agent_outputs", {})
+
+                    import json
+                    conn = _get_conn()
+                    conn.execute(
+                        "INSERT INTO decisions (run_id, date, price, action, size, confidence, reason, agent_outputs, portfolio_value) VALUES (?,?,?,?,?,?,?,?,?)",
+                        (
+                            run_id, TODAY, price,
+                            decision.get("action"), decision.get("size"),
+                            decision.get("confidence"), decision.get("reason"),
+                            json.dumps(agent_outputs), portfolio_value,
+                        ),
+                    )
+                    conn.commit()
+                    conn.close()
+                    logger.info(f"Decision saved: {benchmark}/{model}/{asset}/{TODAY} -> {decision.get('action')}")
+
+                except Exception as e:
+                    logger.error(f"Error for {benchmark}/{model}/{asset}: {e}", exc_info=True)
+
+
+if __name__ == "__main__":
+    run_daily()

llm/openrouter.py

@@ -0,0 +1,105 @@
+import time
+import logging
+import requests
+from threading import Lock
+from collections import deque
+from config import OPENROUTER_API_KEY, OPENROUTER_BASE_URL, MAX_REQUESTS_PER_MINUTE, LLM_TIMEOUT, LLM_MAX_RETRIES
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimiter:
+    """Token-bucket style rate limiter: max N requests per 60s window."""
+
+    def __init__(self, max_per_minute: int = MAX_REQUESTS_PER_MINUTE):
+        self.max_per_minute = max_per_minute
+        self.timestamps: deque = deque()
+        self.lock = Lock()
+
+    def acquire(self):
+        with self.lock:
+            now = time.time()
+            # Remove timestamps older than 60s
+            while self.timestamps and now - self.timestamps[0] > 60:
+                self.timestamps.popleft()
+
+            if len(self.timestamps) >= self.max_per_minute:
+                sleep_for = 60 - (now - self.timestamps[0]) + 0.1
+                logger.info(f"Rate limit reached, sleeping {sleep_for:.1f}s")
+                time.sleep(sleep_for)
+                now = time.time()
+                while self.timestamps and now - self.timestamps[0] > 60:
+                    self.timestamps.popleft()
+
+            self.timestamps.append(time.time())
+
+
+_rate_limiter = RateLimiter()
+
+
+class OpenRouterClient:
+    def __init__(self, model: str, api_key: str = OPENROUTER_API_KEY):
+        self.model = model
+        self.api_key = api_key
+        self.base_url = OPENROUTER_BASE_URL
+
+    def call(self, system_prompt: str, user_prompt: str) -> str:
+        """Call OpenRouter with retry + exponential backoff. Returns raw text."""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://cryptoagentbench.github.io",
+            "X-Title": "CryptoAgentBench",
+        }
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            "temperature": 0.1,
+            "max_tokens": 512,
+        }
+
+        for attempt in range(LLM_MAX_RETRIES):
+            _rate_limiter.acquire()
+            try:
+                resp = requests.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=payload,
+                    timeout=LLM_TIMEOUT,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                content = data["choices"][0]["message"]["content"]
+                return content
+            except requests.exceptions.Timeout:
+                wait = 2 ** attempt
+                logger.warning(f"Timeout on attempt {attempt+1}, retrying in {wait}s")
+                time.sleep(wait)
+            except requests.exceptions.HTTPError as e:
+                status = e.response.status_code if e.response else None
+                if status in (429, 503, 502):
+                    wait = 2 ** (attempt + 1)
+                    logger.warning(f"HTTP {status} on attempt {attempt+1}, retrying in {wait}s")
+                    time.sleep(wait)
+                else:
+                    logger.error(f"HTTP error {status}: {e}")
+                    break
+            except Exception as e:
+                logger.error(f"LLM call failed: {e}")
+                break
+
+        logger.error(f"All retries failed for model {self.model}, returning HOLD")
+        return '{"action": "HOLD", "size": 0.0, "confidence": 0.0, "reason": "LLM unavailable"}'
+
+
+def ping_model(model: str, api_key: str = OPENROUTER_API_KEY) -> bool:
+    """Quick check if a model is responding."""
+    client = OpenRouterClient(model=model, api_key=api_key)
+    try:
+        result = client.call("You are a test.", "Reply with OK")
+        return bool(result)
+    except Exception:
+        return False

llm/prompts.py

@@ -0,0 +1,190 @@
+TRADER_SYSTEM = """You are a professional crypto trading agent. Your job is to analyze market data and make a single trading decision.
+
+Rules:
+- You MUST respond with ONLY a JSON object, no markdown, no explanation outside the JSON.
+- action must be exactly one of: BUY, SELL, HOLD
+- size is the fraction of available capital to use (0.0 to 1.0)
+- confidence is your confidence level (0.0 to 1.0)
+- reason is a brief explanation (max 100 words)
+
+Response format (strict JSON):
+{"action": "BUY|SELL|HOLD", "size": 0.5, "confidence": 0.7, "reason": "..."}"""
+
+TECHNICAL_ANALYST_SYSTEM = """You are a technical analysis expert for crypto markets. Analyze the provided OHLCV data and technical indicators.
+
+Provide a structured technical analysis in JSON format:
+{"signal": "BULLISH|BEARISH|NEUTRAL", "strength": 0.0, "key_levels": {"support": 0.0, "resistance": 0.0}, "summary": "..."}
+
+Respond ONLY with the JSON object."""
+
+NEWS_ANALYST_SYSTEM = """You are a crypto news sentiment analyst. Analyze the provided news headlines and assess market sentiment.
+
+Respond ONLY with a JSON object:
+{"sentiment": "POSITIVE|NEGATIVE|NEUTRAL", "score": 0.0, "key_themes": ["theme1"], "summary": "..."}
+
+score ranges from -1.0 (very negative) to 1.0 (very positive)."""
+
+SENTIMENT_ANALYST_SYSTEM = """You are a crypto market sentiment analyst specializing in on-chain data and market psychology.
+
+Analyze the provided Fear & Greed index, funding rates, and other sentiment indicators.
+
+Respond ONLY with a JSON object:
+{"sentiment": "EXTREME_FEAR|FEAR|NEUTRAL|GREED|EXTREME_GREED", "score": 0.0, "funding_bias": "LONG|SHORT|NEUTRAL", "summary": "..."}"""
+
+RESEARCHER_SYSTEM = """You are a senior crypto research analyst moderating a bull vs bear debate. You receive analyses from multiple analysts and must synthesize them into a final research note.
+
+Consider both bullish and bearish arguments objectively. Identify the strongest signals.
+
+Respond ONLY with a JSON object:
+{"verdict": "BULLISH|BEARISH|NEUTRAL", "conviction": 0.0, "bull_points": ["..."], "bear_points": ["..."], "synthesis": "..."}
+
+conviction ranges from 0.0 to 1.0."""
+
+RISK_MANAGER_SYSTEM = """You are a crypto portfolio risk manager. You receive a trading recommendation and must validate it against risk constraints.
+
+Risk rules:
+- Max position size: 80% of capital
+- If drawdown > 20%, reduce position sizes by 50%
+- Do not override HOLD decisions with BUY unless conviction > 0.6
+
+Respond ONLY with a JSON object:
+{"approved": true, "adjusted_action": "BUY|SELL|HOLD", "adjusted_size": 0.5, "risk_note": "..."}"""
+
+
+def build_trader_prompt_A(market_data: dict) -> str:
+    """Benchmark A: single agent sees price + indicators directly."""
+    asset = market_data.get("asset", "BTC/USDT")
+    price = market_data.get("current_price", 0)
+    ohlcv = market_data.get("recent_ohlcv", [])
+    indicators = market_data.get("indicators", {})
+    portfolio = market_data.get("portfolio", {})
+
+    ohlcv_text = ""
+    if ohlcv:
+        ohlcv_text = "\nRecent OHLCV (last 7 days):\n"
+        for row in ohlcv[-7:]:
+            ohlcv_text += f"  {row['date']}: O={row['open']:.2f} H={row['high']:.2f} L={row['low']:.2f} C={row['close']:.2f} V={row['volume']:.0f}\n"
+
+    ind_text = ""
+    if indicators:
+        ind_text = f"""
+Technical Indicators:
+  RSI(14): {indicators.get('rsi', 'N/A')}
+  MA(20): {indicators.get('ma20', 'N/A')}
+  MA(50): {indicators.get('ma50', 'N/A')}
+  MACD: {indicators.get('macd', 'N/A')}
+  MACD Signal: {indicators.get('macd_signal', 'N/A')}
+  MACD Hist: {indicators.get('macd_hist', 'N/A')}
+  Bollinger Upper: {indicators.get('bb_upper', 'N/A')}
+  Bollinger Lower: {indicators.get('bb_lower', 'N/A')}"""
+
+    port_text = f"""
+Portfolio Status:
+  Cash: ${portfolio.get('cash', 0):.2f}
+  Position: {portfolio.get('position', 0):.6f} {asset.split('/')[0]}
+  Total Value: ${portfolio.get('total_value', 0):.2f}"""
+
+    return f"""Asset: {asset}
+Current Price: ${price:.2f}
+{ohlcv_text}{ind_text}{port_text}
+
+Based on this data, make your trading decision."""
+
+
+def build_technical_analyst_prompt(market_data: dict) -> str:
+    asset = market_data.get("asset", "BTC/USDT")
+    price = market_data.get("current_price", 0)
+    ohlcv = market_data.get("recent_ohlcv", [])
+    indicators = market_data.get("indicators", {})
+
+    ohlcv_text = ""
+    if ohlcv:
+        ohlcv_text = "\nRecent OHLCV (last 14 days):\n"
+        for row in ohlcv[-14:]:
+            ohlcv_text += f"  {row['date']}: O={row['open']:.2f} H={row['high']:.2f} L={row['low']:.2f} C={row['close']:.2f} V={row['volume']:.0f}\n"
+
+    ind_text = f"""
+Indicators:
+  RSI(14): {indicators.get('rsi', 'N/A')}
+  MA(20): {indicators.get('ma20', 'N/A')} | MA(50): {indicators.get('ma50', 'N/A')}
+  MACD: {indicators.get('macd', 'N/A')} | Signal: {indicators.get('macd_signal', 'N/A')}
+  BB Upper: {indicators.get('bb_upper', 'N/A')} | BB Lower: {indicators.get('bb_lower', 'N/A')}"""
+
+    return f"Asset: {asset}\nCurrent Price: ${price:.2f}\n{ohlcv_text}{ind_text}\n\nProvide your technical analysis."
+
+
+def build_news_analyst_prompt(news_items: list, asset: str) -> str:
+    if not news_items:
+        return f"No news available for {asset}. Respond with neutral sentiment."
+    headlines = "\n".join(f"- {item.get('title', '')}" for item in news_items[:10])
+    return f"Asset: {asset}\n\nRecent news headlines:\n{headlines}\n\nAnalyze the sentiment."
+
+
+def build_sentiment_analyst_prompt(onchain_data: dict, asset: str) -> str:
+    fng = onchain_data.get("fear_greed", {})
+    funding = onchain_data.get("funding_rate", None)
+    return f"""Asset: {asset}
+
+Fear & Greed Index: {fng.get('value', 'N/A')} ({fng.get('label', 'N/A')})
+Funding Rate: {f'{funding:.4f}%' if funding is not None else 'N/A'}
+
+Analyze the market sentiment."""
+
+
+def build_researcher_prompt(tech_analysis: dict, news_analysis: dict, sentiment_analysis: dict, asset: str) -> str:
+    return f"""Asset: {asset}
+
+Technical Analysis:
+{tech_analysis}
+
+News Analysis:
+{news_analysis}
+
+Sentiment Analysis:
+{sentiment_analysis}
+
+Synthesize these analyses into a final research verdict."""
+
+
+def build_risk_manager_prompt(recommendation: dict, portfolio: dict) -> str:
+    return f"""Trading Recommendation:
+{recommendation}
+
+Portfolio Status:
+  Cash: ${portfolio.get('cash', 0):.2f}
+  Position: {portfolio.get('position', 0):.6f}
+  Total Value: ${portfolio.get('total_value', 0):.2f}
+  Current Drawdown: {portfolio.get('drawdown', 0):.1%}
+
+Validate this recommendation against risk constraints."""
+
+
+def build_trader_prompt_B(tech_analysis: dict, news_analysis: dict, portfolio: dict, asset: str, price: float) -> str:
+    return f"""Asset: {asset}
+Current Price: ${price:.2f}
+
+Technical Analysis Summary: {tech_analysis.get('summary', 'N/A')} (Signal: {tech_analysis.get('signal', 'N/A')})
+News Sentiment Summary: {news_analysis.get('summary', 'N/A')} (Sentiment: {news_analysis.get('sentiment', 'N/A')}, Score: {news_analysis.get('score', 0):.2f})
+
+Portfolio:
+  Cash: ${portfolio.get('cash', 0):.2f}
+  Total Value: ${portfolio.get('total_value', 0):.2f}
+
+Make your trading decision based on the analyses above."""
+
+
+def build_trader_prompt_C(research: dict, risk_decision: dict, portfolio: dict, asset: str, price: float) -> str:
+    return f"""Asset: {asset}
+Current Price: ${price:.2f}
+
+Research Verdict: {research.get('verdict', 'N/A')} (Conviction: {research.get('conviction', 0):.2f})
+Research Synthesis: {research.get('synthesis', 'N/A')}
+
+Risk Manager Assessment: {risk_decision.get('risk_note', 'N/A')}
+Risk-Adjusted Action: {risk_decision.get('adjusted_action', 'HOLD')} (size: {risk_decision.get('adjusted_size', 0)})
+
+Portfolio:
+  Cash: ${portfolio.get('cash', 0):.2f}
+  Total Value: ${portfolio.get('total_value', 0):.2f}
+
+Make your final trading decision."""

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.5
+uvicorn[standard]==0.32.1
+pydantic==2.9.2
+requests==2.32.3
+pandas==2.2.3
+numpy==2.1.3
+yfinance==0.2.50
+ccxt==4.4.32
+python-dotenv==1.0.1