perf: raise rate limit to 200/min for paid-tier models

app.py

@@ -11,7 +11,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from typing import Optional
 
-from config import BENCHMARKS, FREE_MODELS, ASSETS
+from config import BENCHMARKS, FREE_MODELS, AVAILABLE_MODELS, ASSETS, OPENROUTER_API_KEY
 from db.store import init_db, create_run, complete_run, fail_run, get_run, get_leaderboard, get_decisions
 from backtest.runner import run_backtest
 
@@ -25,13 +25,12 @@ logger = logging.getLogger(__name__)
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     init_db()
-    logger.info("CryptoAgentBench API started")
+    logger.info("DB initialised")
     yield
 
 
 app = FastAPI(
     title="CryptoAgentBench API",
-    description="Benchmark open-source LLMs as crypto trading agents",
     version="1.0.0",
     lifespan=lifespan,
 )
@@ -49,7 +48,7 @@ app.add_middleware(
 
 class BacktestRequest(BaseModel):
     benchmark: str = Field(..., description="A, B, or C")
-    model: str = Field(default="meta-llama/llama-3.3-70b-instruct:free")
+    model: str = Field(default="google/gemma-4-31b-it: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")
@@ -91,11 +90,34 @@ def health():
     }
 
 
+@app.get("/health/llm")
+def health_llm():
+    import requests as req
+    key = OPENROUTER_API_KEY
+    if not key:
+        return {"llm_ok": False, "error": "OPENROUTER_API_KEY not set", "key_prefix": None}
+    key_prefix = key[:6] + "..." if len(key) > 6 else "(short)"
+    try:
+        resp = req.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+            json={"model": FREE_MODELS[0], "messages": [{"role": "user", "content": "Reply OK"}], "max_tokens": 5},
+            timeout=20,
+        )
+        if resp.status_code == 200:
+            return {"llm_ok": True, "key_prefix": key_prefix, "status": 200}
+        return {"llm_ok": False, "key_prefix": key_prefix, "status": resp.status_code, "error": resp.text[:200]}
+    except Exception as e:
+        return {"llm_ok": False, "key_prefix": key_prefix, "error": str(e)[:200]}
+
+
 @app.get("/models")
 def list_models():
     return {
-        "models": FREE_MODELS,
-        "note": "All models are free-tier via OpenRouter",
+        "free_models": FREE_MODELS,
+        "paid_models": AVAILABLE_MODELS[len(FREE_MODELS):],
+        "models": AVAILABLE_MODELS,
+        "note": "Free models via OpenRouter free tier; paid models are affordable open-source.",
     }
 
 
@@ -147,7 +169,6 @@ 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", [])

config.py

@@ -4,13 +4,25 @@ import os
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
 OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
 
-# Free models on OpenRouter
+# Free models on OpenRouter (verified working 2026-06)
 FREE_MODELS = [
-    "deepseek/deepseek-r1:free",
+    "google/gemma-4-31b-it:free",
+    "google/gemma-4-26b-a4b-it:free",
+    "nvidia/nemotron-3-super-120b-a12b:free",
     "meta-llama/llama-3.3-70b-instruct:free",
-    "qwen/qwen3-coder:free",
 ]
-DEFAULT_MODEL = FREE_MODELS[1]
+DEFAULT_MODEL = FREE_MODELS[0]
+
+# Paid (affordable) open-source models via OpenRouter
+PAID_MODELS = [
+    "meta-llama/llama-3.1-8b-instruct",
+    "google/gemma-4-26b-a4b-it",
+    "qwen/qwen3.5-9b",
+    "meta-llama/llama-3.3-70b-instruct",
+]
+
+# All available models (union)
+AVAILABLE_MODELS = FREE_MODELS + PAID_MODELS
 
 # Supported assets
 ASSETS = ["BTC/USDT", "ETH/USDT"]
@@ -26,8 +38,9 @@ BENCHMARKS = ["A", "B", "C"]
 INITIAL_CAPITAL = 10_000.0
 TRADE_FEE = 0.001  # 0.1%
 
-# Rate limiting (OpenRouter free tier)
-MAX_REQUESTS_PER_MINUTE = 18  # conservative under 20
+# Rate limiting — paid OpenRouter tier supports 200+ req/min
+# 60/min shared across parallel runs → ~15/run when 4 run simultaneously
+MAX_REQUESTS_PER_MINUTE = 200
 LLM_TIMEOUT = 120
 LLM_MAX_RETRIES = 3
 

data/prices.py

@@ -1,17 +1,284 @@
 import logging
+import time
 from datetime import datetime, timedelta
 import pandas as pd
+import requests
 
 logger = logging.getLogger(__name__)
 
+ASSET_CRYPTOCOMPARE_MAP = {
+    "BTC/USDT": ("BTC", "USD"),
+    "ETH/USDT": ("ETH", "USD"),
+}
+ASSET_COINBASE_MAP = {
+    "BTC/USDT": "BTC-USD",
+    "ETH/USDT": "ETH-USD",
+}
+ASSET_KRAKEN_MAP = {
+    "BTC/USDT": "XXBTZUSD",
+    "ETH/USDT": "XETHZUSD",
+}
+ASSET_BINANCE_MAP = {
+    "BTC/USDT": "BTCUSDT",
+    "ETH/USDT": "ETHUSDT",
+}
+
 
 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)
+    """Fetch OHLCV data from multiple sources in order."""
+    errors = []
+    for name, fn in [
+        ("CryptoCompare", _fetch_cryptocompare),
+        ("Coinbase", _fetch_coinbase),
+        ("Kraken", _fetch_kraken),
+        ("Binance-REST", _fetch_binance),
+        ("ccxt", _fetch_ccxt),
+        ("yfinance", _fetch_yfinance),
+    ]:
+        try:
+            df = fn(asset, start_date, end_date)
+            if df is not None and not df.empty:
+                logger.info(f"Fetched {len(df)} candles for {asset} via {name}")
+                return df
+        except Exception as e:
+            errors.append(f"{name}: {e}")
+            logger.warning(f"{name} failed for {asset}: {e}")
+
+    raise ValueError(f"All data sources failed for {asset}: {'; '.join(errors)}")
+
+
+def _fetch_cryptocompare(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    """CryptoCompare free API — no auth required, works from any IP."""
+    mapping = ASSET_CRYPTOCOMPARE_MAP.get(asset)
+    if not mapping:
+        raise ValueError(f"No CryptoCompare mapping for {asset}")
+    fsym, tsym = mapping
+
+    start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+    end_dt = datetime.strptime(end_date, "%Y-%m-%d")
+    days_total = (end_dt - start_dt).days + 1
+
+    all_rows = []
+    # CryptoCompare returns up to 2000 daily candles per call
+    batch_size = 2000
+    to_ts = int(end_dt.timestamp()) + 86400
+
+    while to_ts > int(start_dt.timestamp()):
+        limit = min(batch_size, days_total)
+        resp = requests.get(
+            "https://min-api.cryptocompare.com/data/v2/histoday",
+            params={
+                "fsym": fsym,
+                "tsym": tsym,
+                "limit": limit,
+                "toTs": to_ts,
+            },
+            timeout=30,
+            headers={"User-Agent": "CryptoAgentBench/1.0"},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("Response") != "Success":
+            raise ValueError(f"CryptoCompare error: {data.get('Message', data)}")
+
+        candles = data["Data"]["Data"]
+        if not candles:
+            break
+
+        for c in candles:
+            date_str = datetime.utcfromtimestamp(c["time"]).strftime("%Y-%m-%d")
+            if date_str < start_date or date_str > end_date:
+                continue
+            if c["close"] == 0:
+                continue
+            all_rows.append({
+                "date": date_str,
+                "open": float(c["open"]),
+                "high": float(c["high"]),
+                "low": float(c["low"]),
+                "close": float(c["close"]),
+                "volume": float(c["volumefrom"]),
+            })
+
+        earliest = datetime.utcfromtimestamp(candles[0]["time"]).strftime("%Y-%m-%d")
+        if earliest <= start_date:
+            break
+        to_ts = int(candles[0]["time"]) - 1
+
+    if not all_rows:
+        raise ValueError(f"No CryptoCompare data for {fsym}/{tsym} in range {start_date}-{end_date}")
+
+    df = pd.DataFrame(all_rows)
+    df = df.drop_duplicates("date").sort_values("date").reset_index(drop=True)
+    return df
+
+
+def _fetch_coinbase(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    """Coinbase Advanced Trade public API — no auth, US-IP friendly."""
+    product_id = ASSET_COINBASE_MAP.get(asset)
+    if not product_id:
+        raise ValueError(f"No Coinbase mapping for {asset}")
+
+    start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+    end_dt = datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)
+
+    all_rows = []
+    # Coinbase returns max 300 candles per call for granularity=86400
+    chunk_days = 290
+    current = start_dt
+
+    while current < end_dt:
+        chunk_end = min(current + timedelta(days=chunk_days), end_dt)
+        resp = requests.get(
+            f"https://api.exchange.coinbase.com/products/{product_id}/candles",
+            params={
+                "granularity": 86400,
+                "start": current.isoformat(),
+                "end": chunk_end.isoformat(),
+            },
+            timeout=30,
+            headers={"User-Agent": "CryptoAgentBench/1.0"},
+        )
+        resp.raise_for_status()
+        candles = resp.json()
+        if isinstance(candles, dict) and "message" in candles:
+            raise ValueError(f"Coinbase error: {candles['message']}")
+
+        for c in candles:
+            # Format: [timestamp, low, high, open, close, volume]
+            ts, low, high, open_, close, vol = c[0], c[1], c[2], c[3], c[4], c[5]
+            date_str = datetime.utcfromtimestamp(ts).strftime("%Y-%m-%d")
+            if date_str < start_date or date_str > end_date:
+                continue
+            all_rows.append({
+                "date": date_str,
+                "open": float(open_),
+                "high": float(high),
+                "low": float(low),
+                "close": float(close),
+                "volume": float(vol),
+            })
+
+        current = chunk_end
+        time.sleep(0.2)
+
+    if not all_rows:
+        raise ValueError(f"No Coinbase data for {product_id} in range {start_date}-{end_date}")
+
+    df = pd.DataFrame(all_rows)
+    df = df.drop_duplicates("date").sort_values("date").reset_index(drop=True)
+    return df
+
+
+def _fetch_kraken(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    pair = ASSET_KRAKEN_MAP.get(asset)
+    if not pair:
+        raise ValueError(f"No Kraken pair for {asset}")
+
+    since = int(datetime.strptime(start_date, "%Y-%m-%d").timestamp())
+    end_ts = int(
+        (datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)).timestamp()
+    )
+
+    all_rows = []
+    current_since = since
+
+    for _ in range(10):
+        resp = requests.get(
+            "https://api.kraken.com/0/public/OHLC",
+            params={"pair": pair, "interval": 1440, "since": current_since},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("error"):
+            raise ValueError(f"Kraken error: {data['error']}")
+
+        # Result dict has pair key + "last" key
+        pair_keys = [k for k in data["result"] if k != "last"]
+        if not pair_keys:
+            break
+        candles = data["result"][pair_keys[0]]
+        last = data["result"].get("last", 0)
+
+        added = 0
+        for c in candles:
+            ts = int(c[0])
+            if ts >= end_ts:
+                break
+            date_str = datetime.utcfromtimestamp(ts).strftime("%Y-%m-%d")
+            if start_date <= date_str <= end_date:
+                all_rows.append({
+                    "date": date_str,
+                    "open": float(c[1]),
+                    "high": float(c[2]),
+                    "low": float(c[3]),
+                    "close": float(c[4]),
+                    "volume": float(c[6]),
+                })
+                added += 1
+
+        if last == 0 or last >= end_ts or len(candles) < 720:
+            break
+        current_since = last
+        time.sleep(0.5)
+
+    if not all_rows:
+        raise ValueError(f"No Kraken data for {pair} in range {start_date}-{end_date}")
+
+    df = pd.DataFrame(all_rows)
+    df = df.drop_duplicates("date").sort_values("date").reset_index(drop=True)
+    return df
+
+
+def _fetch_binance(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
+    symbol = ASSET_BINANCE_MAP.get(asset)
+    if not symbol:
+        raise ValueError(f"No Binance symbol for {asset}")
+
+    start_ms = int(datetime.strptime(start_date, "%Y-%m-%d").timestamp() * 1000)
+    end_ms = int(
+        (datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)).timestamp() * 1000
+    )
+
+    all_candles = []
+    current_start = start_ms
+
+    while current_start < end_ms:
+        resp = requests.get(
+            "https://api.binance.com/api/v3/klines",
+            params={
+                "symbol": symbol,
+                "interval": "1d",
+                "startTime": current_start,
+                "endTime": end_ms,
+                "limit": 1000,
+            },
+            timeout=30,
+        )
+        resp.raise_for_status()
+        candles = resp.json()
+        if not candles:
+            break
+        all_candles.extend(candles)
+        current_start = candles[-1][0] + 86400000
+        if len(candles) < 1000:
+            break
+
+    if not all_candles:
+        raise ValueError(f"No data from Binance for {symbol}")
+
+    df = pd.DataFrame(all_candles, columns=[
+        "timestamp", "open", "high", "low", "close", "volume",
+        "close_time", "quote_volume", "num_trades",
+        "taker_buy_base", "taker_buy_quote", "ignore",
+    ])
+    df["date"] = pd.to_datetime(df["timestamp"], unit="ms").dt.strftime("%Y-%m-%d")
+    df = df[(df["date"] >= start_date) & (df["date"] <= end_date)]
+    for col in ["open", "high", "low", "close", "volume"]:
+        df[col] = df[col].astype(float)
+    df = df.drop_duplicates("date").sort_values("date").reset_index(drop=True)
+    return df[["date", "open", "high", "low", "close", "volume"]]
 
 
 def _fetch_ccxt(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
@@ -48,7 +315,6 @@ def _fetch_yfinance(asset: str, start_date: str, end_date: str) -> pd.DataFrame:
     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)