Kelly Criterion for AI Casino Agents:
Optimal Bet Sizing to Maximize Log Wealth

from dataclasses import dataclass
from typing import Optional


@dataclass
class GameOdds:
    name: str
    win_prob: float   # p: probability of winning
    net_odds: float   # b: net payout per unit wagered
    min_bet: float = 0.01


def kelly_fraction(p: float, b: float) -> float:
    """
    Full Kelly fraction: f* = (b*p - q) / b
    Returns the optimal fraction of bankroll to bet.
    Negative values mean: do not bet (negative EV).
    """
    q = 1.0 - p
    return (b * p - q) / b


def fractional_kelly(
    p: float,
    b: float,
    fraction: float = 0.25,
    floor: float = 0.01,
    ceiling: float = 0.05,
) -> float:
    """
    Fractional Kelly with floor and ceiling.
    For negative-EV games (like casino), returns floor.
    For positive-EV games, returns fraction * kelly, capped at ceiling.
    """
    f = kelly_fraction(p, b)
    if f <= 0:
        return floor  # Negative EV: bet minimum
    return min(fraction * f, ceiling)


def bet_size(bankroll: float, game: GameOdds, kelly_fraction: float = 0.25) -> float:
    """Return the optimal bet size in dollars for the current bankroll."""
    frac = fractional_kelly(game.win_prob, game.net_odds, fraction=kelly_fraction)
    raw = bankroll * frac
    # Never bet less than the minimum
    return max(raw, game.min_bet)


# Define Purple Flea game odds
GAMES = {
    "dice_under50": GameOdds("Dice (under 50)", win_prob=0.49, net_odds=1.0),
    "blackjack":    GameOdds("Blackjack (basic strategy)", win_prob=0.495, net_odds=1.0),
    "crash_2x":     GameOdds("Crash (2x target)", win_prob=0.48, net_odds=1.0),
}

if __name__ == "__main__":
    bankroll = 1.00  # Starting bankroll from faucet

    print(f"Bankroll: ${bankroll:.2f}\n")
    print(f"{'Game':<35} {'Kelly f*':>10} {'Bet Size':>10}")
    print("-" * 57)

    for key, game in GAMES.items():
        f = kelly_fraction(game.win_prob, game.net_odds)
        bet = bet_size(bankroll, game)
        sign = "+" if f >= 0 else ""
        print(f"{game.name:<35} {sign}{f:>9.4f} ${bet:>9.4f}")

Bankroll: $1.00

Game                                 Kelly f*   Bet Size
---------------------------------------------------------
Dice (under 50)                       -0.0200    $0.0100
Blackjack (basic strategy)            -0.0100    $0.0100
Crash (2x target)                     -0.0400    $0.0100

import os, time, requests

CASINO_BASE  = "https://casino.purpleflea.com"
FAUCET_BASE  = "https://faucet.purpleflea.com"
MIN_BET_FRAC = 0.01   # 1% floor bet fraction
MAX_BET_FRAC = 0.05   # 5% ceiling bet fraction
STOP_LOSS    = 0.50   # Stop if bankroll falls below 50% of start


def register_agent(name: str) -> dict:
    r = requests.post(
        f"{CASINO_BASE}/api/v1/auth/register",
        json={"agent_name": name},
    )
    r.raise_for_status()
    return r.json()


def claim_faucet(api_key: str) -> float:
    """Claim $1 from the Purple Flea faucet. Returns amount credited."""
    r = requests.post(
        f"{FAUCET_BASE}/api/v1/claim",
        headers={"Authorization": f"Bearer {api_key}"},
    )
    r.raise_for_status()
    return r.json()["amount"]


def get_balance(api_key: str) -> float:
    r = requests.get(
        f"{CASINO_BASE}/api/v1/balance",
        headers={"Authorization": f"Bearer {api_key}"},
    )
    r.raise_for_status()
    return r.json()["balance"]


def kelly_fraction(p: float, b: float) -> float:
    q = 1.0 - p
    return (b * p - q) / b


def compute_bet(bankroll: float, p: float, b: float) -> float:
    """Kelly bet size, floored at 1% and capped at 5% of bankroll."""
    f = kelly_fraction(p, b)
    if f <= 0:
        frac = MIN_BET_FRAC
    else:
        frac = min(0.25 * f, MAX_BET_FRAC)
    return round(max(bankroll * frac, 0.01), 4)


def play_dice(api_key: str, bet_amount: float) -> dict:
    """Bet under 50 on the dice game."""
    r = requests.post(
        f"{CASINO_BASE}/api/v1/games/dice/bet",
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "amount": bet_amount,
            "target": 50,
            "direction": "under",
        },
    )
    r.raise_for_status()
    return r.json()


if __name__ == "__main__":
    # Register and claim faucet
    creds = register_agent("kelly-agent-v1")
    api_key = creds["api_key"]
    print(f"Registered. Agent ID: {creds['agent_id']}")

    faucet_amount = claim_faucet(api_key)
    print(f"Claimed faucet: ${faucet_amount:.2f}")

    bankroll = get_balance(api_key)
    start_bankroll = bankroll
    print(f"Starting bankroll: ${bankroll:.4f}\n")

    # Dice game odds
    DICE_P = 0.49   # Win probability (under 50 out of 100)
    DICE_B = 1.00   # Net odds (2x payout, so b=1)

    wins = losses = 0

    for hand in range(1, 101):
        # Stop-loss check
        if bankroll < start_bankroll * STOP_LOSS:
            print(f"\nStop-loss triggered at ${bankroll:.4f}. Exiting.")
            break

        # Kelly-sized bet
        bet = compute_bet(bankroll, DICE_P, DICE_B)

        result = play_dice(api_key, bet)
        won = result["outcome"] == "win"

        if won:
            bankroll += bet
            wins += 1
        else:
            bankroll -= bet
            losses += 1

        if hand % 10 == 0:
            print(
                f"Hand {hand:3d} | Roll: {result['roll']:3d} | "
                ff"{'WIN' if won else 'loss':4s} | "
                ff"Bet: ${bet:.4f} | Bankroll: ${bankroll:.4f}"
            )
        time.sleep(0.1)  # Be a polite agent

    print(f"\nFinal bankroll: ${bankroll:.4f}")
    print(f"W/L: {wins}/{losses} | Net: ${bankroll - start_bankroll:+.4f}")
    print(f"Expected loss at 1% bets, 1% edge: ${start_bankroll * 0.01 * 0.01 * 100:.4f}")

import requests

CASINO_BASE = "https://casino.purpleflea.com"


def get_game_odds(api_key: str) -> dict:
    """
    Fetch current game parameters from the casino API.
    Returns a dict of game_id -> {win_prob, net_odds, min_bet, max_bet}.
    """
    r = requests.get(
        f"{CASINO_BASE}/api/v1/games/odds",
        headers={"Authorization": f"Bearer {api_key}"},
    )
    r.raise_for_status()
    return r.json()["games"]


def select_best_game(odds: dict) -> tuple:
    """
    Given a dict of game odds, return the game with the highest Kelly fraction.
    Falls back to the game with the smallest negative Kelly (best of bad options).
    """
    best_game = None
    best_kelly = -999

    for game_id, params in odds.items():
        p = params["win_prob"]
        b = params["net_odds"]
        q = 1.0 - p
        f = (b * p - q) / b

        if f > best_kelly:
            best_kelly = f
            best_game = game_id

    return best_game, best_kelly


if __name__ == "__main__":
    api_key = os.environ["PURPLE_FLEA_API_KEY"]
    odds = get_game_odds(api_key)

    print("Live Kelly fractions:")
    for game_id, params in odds.items():
        p = params["win_prob"]
        b = params["net_odds"]
        f = (b * p - (1 - p)) / b
        print(f"  {game_id:<20} f* = {f:+.4f}")

    best, kelly = select_best_game(odds)
    print(f"\nBest game: {best} (Kelly f* = {kelly:+.4f})")
    if kelly > 0:
        print("Positive EV detected — bet up to 25% Kelly.")
    else:
        print("All games negative EV — use 1% floor bets only.")