Options Trading for AI Agents:
Calls, Puts, and Automated Strategies

import requests, os
from datetime import datetime, timedelta

PF_BASE = "https://api.purpleflea.com"
HEADERS = {"Authorization": f"Bearer {os.environ['PF_API_KEY']}"}
UNDERLYING = "ETH"
ETH_HELD = 1.0  # ETH in treasury available for covered calls
OTM_PCT = 0.06  # sell calls 6% above current price


def roll_covered_call():
    # Get current ETH spot price and options chain
    chain = requests.get(
        f"{PF_BASE}/v1/options/chain",
        params={"underlying": UNDERLYING, "expiry_days": 7},
        headers=HEADERS
    ).json()

    spot = chain["spot_price"]
    target_strike = round(spot * (1 + OTM_PCT), -2)  # round to nearest $100

    # Find the call closest to target strike
    calls = [c for c in chain["contracts"] if c["type"] == "call"]
    best = min(calls, key=lambda c: abs(c["strike"] - target_strike))

    print(f"Spot: ${spot:,.0f} | Selling {best['strike']} call | Premium: ${best['premium']:.2f} | IV: {best['iv']:.1f}%")

    # Check minimum premium threshold (skip if IV too low)
    if best["premium"] < spot * 0.005:  # skip if < 0.5% of spot
        print("Premium too low — skipping this week")
        return

    # Sell the covered call (quantity = ETH held)
    order = requests.post(
        f"{PF_BASE}/v1/options/order",
        json={
            "underlying": UNDERLYING,
            "type": "call",
            "side": "sell",
            "strike": best["strike"],
            "expiry": best["expiry"],
            "quantity": ETH_HELD,
            "order_type": "market"
        },
        headers=HEADERS
    ).json()

    print(f"Sold ${best['strike']} call | Order ID: {order['order_id']} | Income: ${order['premium_received']:.2f}")


if __name__ == "__main__":
    roll_covered_call()

def buy_momentum_call(underlying: str, spot: float, portfolio_usd: float):
    # Get options chain for 7-day expiry
    chain = requests.get(
        f"{PF_BASE}/v1/options/chain",
        params={"underlying": underlying, "expiry_days": 7},
        headers=HEADERS
    ).json()

    # Find call with delta closest to 0.30 (OTM but with meaningful probability)
    calls = [c for c in chain["contracts"] if c["type"] == "call"]
    target_delta = 0.30
    best = min(calls, key=lambda c: abs(c["greeks"]["delta"] - target_delta))

    # Allocate 3% of portfolio to this trade
    max_spend_usd = portfolio_usd * 0.03
    quantity = min(1.0, max_spend_usd / (best["premium"] * spot))  # options are sized per underlying unit

    print(f"Buying {quantity:.3f}x {best['strike']} call | Delta: {best['greeks']['delta']:.2f}")
    print(f"Cost: ${best['premium'] * spot * quantity:.2f} | Max loss: ${best['premium'] * spot * quantity:.2f}")
    print(f"Breakeven at expiry: ${best['strike'] + best['premium']:.0f}")

    order = requests.post(
        f"{PF_BASE}/v1/options/order",
        json={
            "underlying": underlying,
            "type": "call",
            "side": "buy",
            "strike": best["strike"],
            "expiry": best["expiry"],
            "quantity": round(quantity, 3),
            "order_type": "limit",
            "limit_price": best["premium"] * 1.02  # 2% slippage tolerance
        },
        headers=HEADERS
    ).json()
    return order

def enter_strangle_if_iv_high(underlying: str, iv_rank_threshold: float = 80.0):
    # Get current IV rank (0-100 scale, where 100 = highest IV in 52 weeks)
    iv_data = requests.get(
        f"{PF_BASE}/v1/options/iv-rank",
        params={"underlying": underlying},
        headers=HEADERS
    ).json()

    if iv_data["iv_rank"] < iv_rank_threshold:
        print(f"IV Rank {iv_data['iv_rank']:.0f} below threshold {iv_rank_threshold} — no strangle")
        return None

    print(f"IV Rank: {iv_data['iv_rank']:.0f} — entering strangle")

    # Get chain for 21-day expiry (optimal theta/gamma ratio for short strangles)
    chain = requests.get(
        f"{PF_BASE}/v1/options/chain",
        params={"underlying": underlying, "expiry_days": 21},
        headers=HEADERS
    ).json()

    # Find ~0.20 delta OTM call and ~-0.20 delta OTM put
    calls = [c for c in chain["contracts"] if c["type"] == "call"]
    puts  = [p for p in chain["contracts"] if p["type"] == "put"]

    short_call = min(calls, key=lambda c: abs(c["greeks"]["delta"] - 0.20))
    short_put  = min(puts,  key=lambda p: abs(p["greeks"]["delta"] + 0.20))

    total_premium = short_call["premium"] + short_put["premium"]
    spot = chain["spot_price"]

    print(f"Strangle: sell {short_call['strike']} call + {short_put['strike']} put")
    print(f"Total premium: ${total_premium * spot:.2f} | Profitable range: ${short_put['strike']:.0f}–${short_call['strike']:.0f}")

    # Enter both legs
    for leg, leg_type in [(short_call, "call"), (short_put, "put")]:
        requests.post(
            f"{PF_BASE}/v1/options/order",
            json={
                "underlying": underlying,
                "type": leg_type,
                "side": "sell",
                "strike": leg["strike"],
                "expiry": leg["expiry"],
                "quantity": 1.0,
                "order_type": "market"
            },
            headers=HEADERS
        )


if __name__ == "__main__":
    enter_strangle_if_iv_high("ETH")