AI Agent Poker Strategy: GTO, Exploitative Play, and Bankroll

# GTO Bluff Frequency Calculator
# Based on pot geometry and bet sizing theory

from dataclasses import dataclass
from typing import Tuple
import math

@dataclass
class PotState:
    pot: float
    effective_stack: float
    position: str  # 'IP' (in position) or 'OOP'
    street: str    # 'flop', 'turn', 'river'

class GTOCalculator:
    """
    Computes GTO frequencies for common poker decisions.
    Implements basic Nash Equilibrium principles for poker.
    """

    def bluff_frequency(self, bet_size: float, pot: float) -> float:
        """
        GTO bluff frequency = bet / (bet + pot)
        Opponent must call this % to prevent profitable bluffs.
        """
        return bet_size / (bet_size + pot)

    def call_frequency(self, bet_size: float, pot: float) -> float:
        """
        GTO call frequency = pot / (pot + bet)
        We must call this % to make bluffs break-even for villain.
        """
        return pot / (pot + bet_size)

    def pot_odds(self, bet_size: float, pot: float) -> float:
        """Minimum equity needed to profitably call."""
        return bet_size / (pot + 2 * bet_size)

    def optimal_bet_size(self, pot: float, ev_ratio: float = 0.75) -> float:
        """
        Compute bet size that achieves target fold equity.
        ev_ratio=0.75 means we want opponent indifferent at 75% pot.
        """
        return pot * ev_ratio

    def value_to_bluff_ratio(self, bet_size: float, pot: float) -> float:
        """
        For every value bet, how many bluffs should we include?
        = call_frequency / bluff_frequency
        """
        call_freq = self.call_frequency(bet_size, pot)
        bluff_freq = self.bluff_frequency(bet_size, pot)
        return call_freq / bluff_freq

    def compute_strategy(self, state: PotState, bet_size: float) -> dict:
        """Full GTO strategy for a betting decision."""
        bluff_freq = self.bluff_frequency(bet_size, state.pot)
        call_freq = self.call_frequency(bet_size, state.pot)
        pot_odds = self.pot_odds(bet_size, state.pot)
        vtb = self.value_to_bluff_ratio(bet_size, state.pot)

        return {
            "bluff_frequency": round(bluff_freq, 3),
            "call_frequency": round(call_freq, 3),
            "minimum_equity_to_call": round(pot_odds, 3),
            "value_bluff_ratio": round(vtb, 2),
            "pot_if_called": state.pot + 2 * bet_size,
        }

# Example: 75% pot bet on the river
gto = GTOCalculator()
state = PotState(pot=100, effective_stack=500, position='IP', street='river')
strategy = gto.compute_strategy(state, bet_size=75)

print(f"Bet size: $75 into $100 pot")
print(f"We should bluff: {strategy['bluff_frequency']*100:.1f}% of our range")
print(f"Opponent must call: {strategy['call_frequency']*100:.1f}% to prevent exploit")
print(f"Minimum equity to call: {strategy['minimum_equity_to_call']*100:.1f}%")
print(f"Value:Bluff ratio: {strategy['value_bluff_ratio']:.1f}:1")
# Output:
# We should bluff: 42.9% of our range
# Opponent must call: 57.1% to prevent exploit
# Minimum equity to call: 27.3%
# Value:Bluff ratio: 1.3:1

# Complete Poker Agent with Hand Strength + Decision Engine
# Integrates with Purple Flea Casino API

import random
import itertools
from collections import Counter
from typing import List, Tuple, Optional
import requests

# ── Card Representation ──────────────────────────────────────
RANKS = '23456789TJQKA'
SUITS = 'cdhs'
RANK_VAL = {r: i for i, r in enumerate(RANKS)}

def card(s: str) -> tuple:
    """Parse 'Ah', 'Kd', '2c' -> (rank_value, suit)"""
    return (RANK_VAL[s[0]], s[1])

def hand_rank(cards: List[tuple]) -> tuple:
    """
    Evaluate 5-card hand. Returns (category, tiebreakers).
    Categories: 8=SF, 7=Quads, 6=FH, 5=Flush, 4=Straight,
                3=Trips, 2=TwoPair, 1=Pair, 0=HighCard
    """
    ranks = sorted([c[0] for c in cards], reverse=True)
    suits = [c[1] for c in cards]
    is_flush = len(set(suits)) == 1
    is_straight = (ranks[0] - ranks[4] == 4) and len(set(ranks)) == 5
    # Wheel: A-2-3-4-5
    is_wheel = set(ranks) == {12, 0, 1, 2, 3}
    if is_wheel: ranks = [3, 2, 1, 0, -1]; is_straight = True
    counts = Counter(ranks)
    groups = sorted(counts.items(), key=lambda x: (x[1], x[0]), reverse=True)
    g = [cnt for _, cnt in groups]
    rs = [r for r, _ in groups]

    if is_straight and is_flush: return (8, ranks[0])
    if g[0] == 4:                return (7, rs[0], rs[1])
    if g[:2] == [3, 2]:         return (6, rs[0], rs[1])
    if is_flush:                  return (5, *ranks)
    if is_straight:               return (4, ranks[0])
    if g[0] == 3:                return (3, rs[0], *rs[1:])
    if g[:2] == [2, 2]:         return (2, rs[0], rs[1], rs[2])
    if g[0] == 2:                return (1, rs[0], *rs[1:])
    return (0, *ranks)

def best_hand(hole: List[str], board: List[str]) -> tuple:
    """Find best 5-card hand from 7 cards (Texas Hold'em)."""
    all_cards = [card(c) for c in hole + board]
    return max(hand_rank(list(combo))
                for combo in itertools.combinations(all_cards, 5))

def monte_carlo_equity(hole: List[str], board: List[str],
                        n_opponents: int = 1,
                        simulations: int = 5000) -> float:
    """
    Monte Carlo equity simulation against random opponent ranges.
    Fast: 5000 sims runs in ~150ms, good enough for live decisions.
    """
    known = set(hole + board)
    deck = [r+s for r in RANKS for s in SUITS if r+s not in known]
    wins = 0

    for _ in range(simulations):
        remaining = deck[:]
        random.shuffle(remaining)
        ptr = 0
        opp_hands = []
        for _ in range(n_opponents):
            opp_hands.append(remaining[ptr:ptr+2])
            ptr += 2
        run_out = remaining[ptr:ptr+(5-len(board))]
        full_board = board + run_out

        my_strength = best_hand(hole, full_board)
        opp_strengths = [best_hand(opp, full_board) for opp in opp_hands]

        if my_strength >= max(opp_strengths):
            wins += 1

    return wins / simulations


# ── Decision Engine ───────────────────────────────────────────
class PokerAgent:
    """
    Full GTO-informed poker agent with exploitative adjustments.
    Designed to operate via Purple Flea Casino API.
    """
    BASE_URL = "https://purpleflea.com/casino-api"

    def __init__(self, api_key: str, buy_in: float = 100):
        self.api_key = api_key
        self.buy_in = buy_in
        self.session = requests.Session()
        self.session.headers.update({"Authorization": f"Bearer {api_key}"})
        self.gto = GTOCalculator()
        self.opponent_stats = {}

    def decide(self, hole: List[str], board: List[str],
               pot: float, to_call: float,
               position: str, n_opponents: int = 1) -> dict:
        """
        Core decision function. Returns action and sizing.
        Position: 'BTN' (best) > 'CO' > 'MP' > 'UTG' (worst)
                  'BB' / 'SB' (blinds, OOP post-flop)
        """
        equity = monte_carlo_equity(hole, board, n_opponents)
        street = {0:'preflop',3:'flop',4:'turn',5:'river'}[len(board)]
        pos_bonus = {'BTN':0.04,'CO':0.02,'MP':0,'UTG':-0.02,'BB':-0.03,'SB':-0.04}.get(position, 0)
        adj_equity = min(1.0, equity + pos_bonus)
        pot_odds_needed = self.gto.pot_odds(to_call, pot) if to_call > 0 else 0

        if to_call == 0:  # Can check or bet
            if adj_equity > 0.65:
                bet = round(pot * 0.75, 2)
                return {"action":"bet","amount":bet,"equity":adj_equity,"street":street}
            elif adj_equity > 0.40:
                return {"action":"check","amount":0,"equity":adj_equity,"street":street}
            else:
                bluff_thresh = self.gto.bluff_frequency(pot*0.6, pot)
                if random.random() < bluff_thresh and position in ('BTN','CO'):
                    return {"action":"bet","amount":round(pot*0.6,2),"equity":adj_equity,"street":street}
                return {"action":"check","amount":0,"equity":adj_equity,"street":street}
        else:  # Facing a bet
            if adj_equity > pot_odds_needed + 0.15:
                return {"action":"raise","amount":round(to_call*3+pot*0.5,2),"equity":adj_equity,"street":street}
            elif adj_equity > pot_odds_needed:
                return {"action":"call","amount":to_call,"equity":adj_equity,"street":street}
            else:
                return {"action":"fold","amount":0,"equity":adj_equity,"street":street}

# Quick demo
agent = PokerAgent("your-api-key")
decision = agent.decide(
    hole=['Ah','Kd'], board=['As','7c','2h'],
    pot=80, to_call=30, position='BTN'
)
print(decision)
# {'action': 'raise', 'amount': 130.0, 'equity': 0.87, 'street': 'flop'}

# Bankroll Manager with stop-loss and shot-taking logic
import math
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class BankrollManager:
    initial_bankroll: float
    stake_buy_in: float        # Max buy-in at target stake
    min_buy_ins: int = 25      # Min buy-ins required to play
    shot_buy_ins: int = 5       # Take a shot with 5 buy-ins at next stake
    stop_loss_buy_ins: int = 3  # Move down after losing 3 buy-ins
    current_bankroll: float = field(init=False)
    session_start: float = field(init=False)
    hands_played: int = 0
    total_won: float = 0.0

    def __post_init__(self):
        self.current_bankroll = self.initial_bankroll
        self.session_start = self.initial_bankroll

    @property
    def buy_ins_remaining(self) -> float:
        return self.current_bankroll / self.stake_buy_in

    @property
    def can_play_stake(self) -> bool:
        return self.buy_ins_remaining >= self.min_buy_ins

    @property
    def should_move_down(self) -> bool:
        session_loss = self.session_start - self.current_bankroll
        return session_loss >= self.stop_loss_buy_ins * self.stake_buy_in

    @property
    def can_take_shot(self) -> bool:
        next_stake_bi = self.stake_buy_in * 2  # Assume next stake is 2x
        return self.current_bankroll >= self.shot_buy_ins * next_stake_bi

    def risk_of_ruin(self, winrate_bb_per_100: float,
                      variance_bb2: float = 100.0) -> float:
        """Kelly-based risk of ruin estimate."""
        bankroll_bb = self.current_bankroll / (self.stake_buy_in / 100)
        if winrate_bb_per_100 <= 0: return 1.0
        exponent = -2 * winrate_bb_per_100 * bankroll_bb / (variance_bb2 * 100)
        return min(1.0, math.exp(exponent))

    def record_result(self, profit: float, hands: int):
        self.current_bankroll += profit
        self.total_won += profit
        self.hands_played += hands

    def new_session(self):
        self.session_start = self.current_bankroll

    def status(self) -> str:
        ror = self.risk_of_ruin(3.0)
        bb_per_100 = (self.total_won / self.stake_buy_in * 100 /
                     max(1, self.hands_played) * 100)
        return (
            f"Bankroll: ${self.current_bankroll:.2f} | "
            f"Buy-ins: {self.buy_ins_remaining:.1f} | "
            f"RoR: {ror*100:.2f}% | "
            f"Action: {'PLAY' if self.can_play_stake else 'MOVE DOWN'}"
        )

# Example usage
bm = BankrollManager(initial_bankroll=2500, stake_buy_in=100)
bm.record_result(-250, 1000)  # Lost 2.5 buy-ins in 1000 hands
print(bm.status())
# Bankroll: $2250.00 | Buy-ins: 22.5 | RoR: 0.04% | Action: PLAY

if bm.should_move_down:
    print("Stop-loss hit — dropping to NL50 until bankroll recovers")