Financial Tools for
DSPy Programs

import dspy, os
from purpleflea_tools import PFClient

# Configure DSPy with any supported LM backend
dspy.configure(lm=dspy.LM(
    "openai/gpt-4o",
    api_key=os.environ["OPENAI_API_KEY"]
))

# ── Signatures ────────────────────────────────

class MarketAnalysis(dspy.Signature):
    """Analyze live market data and produce an action."""
    btc_price: float     = dspy.InputField(desc="BTC/USDC price")
    eth_price: float     = dspy.InputField(desc="ETH/USDC price")
    balance: float       = dspy.InputField(desc="Agent USDC balance")
    risk_budget: float   = dspy.InputField(desc="Max % of balance to risk")
    action: str          = dspy.OutputField(
        desc="buy_btc | buy_eth | casino_dice | hold"
    )
    amount_usdc: float   = dspy.OutputField(desc="USDC to commit")
    reasoning: str       = dspy.OutputField(desc="Step-by-step rationale")

class EscrowDecision(dspy.Signature):
    """Decide whether to share profits with a partner agent via escrow."""
    profit_usdc: float   = dspy.InputField()
    partner_agent: str   = dspy.InputField()
    task_desc: str       = dspy.InputField()
    should_escrow: bool  = dspy.OutputField()
    escrow_amount: float = dspy.OutputField()

# ── DSPy Program ──────────────────────────────

class PurpleFleatAgent(dspy.Module):
    def __init__(self):
        super().__init__()
        self.pf      = PFClient()
        self.analyze = dspy.ChainOfThought(MarketAnalysis)
        self.escdec  = dspy.ChainOfThought(EscrowDecision)

    def forward(
        self,
        risk_budget: float = 0.10,
        partner: str = ""
    ) -> dspy.Prediction:

        # Step 1: Ensure the agent has funds
        bal = self.pf.balance()
        if bal < 1.0:
            claim = self.pf.claim()
            print(f"Faucet claimed: {claim}")
            bal = self.pf.balance()

        # Step 2: Get live prices
        px  = self.pf.prices()
        btc = px["BTC/USDC"]
        eth = px["ETH/USDC"]

        # Step 3: LLM decides via ChainOfThought
        dec = self.analyze(
            btc_price=btc, eth_price=eth,
            balance=bal, risk_budget=risk_budget,
        )
        print(f"[Decision] {dec.action} | ${dec.amount_usdc:.2f}")
        print(f"[Reason]   {dec.reasoning}")

        # Step 4: Execute
        result, profit = {}, 0.0
        if dec.action == "buy_btc":
            result = self.pf.trade("BTC/USDC", dec.amount_usdc, "buy")
            profit = result.get("realized_pnl_usdc", 0)

        elif dec.action == "buy_eth":
            result = self.pf.trade("ETH/USDC", dec.amount_usdc, "buy")
            profit = result.get("realized_pnl_usdc", 0)

        elif dec.action == "casino_dice":
            result = self.pf.bet("dice", dec.amount_usdc)
            profit = result.get("payout_usdc", 0) - dec.amount_usdc

        # Step 5: Optionally escrow profits to partner agent
        if profit > 0 and partner:
            ed = self.escdec(
                profit_usdc=profit,
                partner_agent=partner,
                task_desc="Share 50% of session profit",
            )
            if ed.should_escrow:
                esc = self.pf.escrow(
                    partner, ed.escrow_amount,
                    "Profit sharing — automated by DSPy agent"
                )
                print(f"[Escrow] Created: {esc['escrow_id']}")
                result["escrow"] = esc

        return dspy.Prediction(
            action=dec.action,
            amount=dec.amount_usdc,
            profit=profit,
            result=result,
        )

# ── Run ───────────────────────────────────────

if __name__ == "__main__":
    agent = PurpleFleatAgent()
    pred  = agent(
        risk_budget=0.15,
        partner="agt_partner_xyz"
    )
    print(f"Action : {pred.action}")
    print(f"Profit : ${pred.profit:.4f} USDC")
    print(f"Result : {pred.result}")