Financial Infrastructure
for SmolAgents

import requests
from smolagents import Tool

class CasinoTool(Tool):
    name = "casino"
    description = (
        "Place a bet at the Purple Flea casino. "
        "Supports: dice, slots, roulette, blackjack. "
        "Returns win/loss result and updated balance."
    )
    inputs = {
        "game":   {"type": "string", "description": "Game type: dice | slots | roulette | blackjack"},
        "amount": {"type": "number", "description": "Bet amount in USDC"},
        "params": {"type": "string", "description": "Optional JSON with game-specific params", "nullable": "true"},
    }
    output_type = "string"

    def __init__(self, api_key: str):
        super().__init__()
        self.api_key = api_key
        self.base = "https://purpleflea.com/casino-api"

    def forward(self, game: str, amount: float, params: str = "{}") -> str:
        import json
        resp = requests.post(
            f"{self.base}/bet",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"game": game, "amount": amount, "params": json.loads(params)},
        )
        resp.raise_for_status()
        data = resp.json()
        result = "WIN" if data["win"] else "LOSS"
        return (
            f"{result}: bet {amount} USDC on {game}. "
            f"Payout: {data['payout']} USDC. Balance: {data['balance']} USDC. "
            f"Provably fair seed: {data['seed']}"
        )

class TradingTool(Tool):
    name = "trading"
    description = (
        "Place buy/sell orders on Purple Flea trading. "
        "Supports spot and perpetual markets. Returns order ID, fill price, status."
    )
    inputs = {
        "pair":       {"type": "string", "description": "Trading pair, e.g. BTC-USDC"},
        "side":       {"type": "string", "description": "buy or sell"},
        "amount":     {"type": "number", "description": "Order size in USDC"},
        "order_type": {"type": "string", "description": "market | limit"},
        "price":      {"type": "number", "description": "Limit price (required if limit)", "nullable": "true"},
    }
    output_type = "string"

    def __init__(self, api_key: str):
        super().__init__()
        self.api_key = api_key

    def forward(self, pair: str, side: str, amount: float,
                order_type: str = "market", price: float = None) -> str:
        payload = {"pair": pair, "side": side, "amount": amount, "type": order_type}
        if price:
            payload["price"] = price
        resp = requests.post(
            "https://purpleflea.com/trading-api/order",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json=payload,
        )
        resp.raise_for_status()
        d = resp.json()
        return (
            f"Order {d['order_id']}: {side.upper()} {amount} USDC of {pair} "
            f"at {d['fill_price']}. Status: {d['status']}"
        )

class EscrowTool(Tool):
    name = "escrow"
    description = (
        "Lock USDC in trustless escrow for agent-to-agent payments. "
        "Actions: create, release, refund, status. 1% fee. Returns escrow ID."
    )
    inputs = {
        "action":    {"type": "string", "description": "create | release | refund | status"},
        "amount":    {"type": "number", "description": "USDC amount (for create)", "nullable": "true"},
        "receiver":  {"type": "string", "description": "Receiver agent ID (for create)", "nullable": "true"},
        "escrow_id": {"type": "string", "description": "Escrow ID (for release/refund/status)", "nullable": "true"},
    }
    output_type = "string"

    def __init__(self, api_key: str):
        super().__init__()
        self.api_key = api_key
        self.base = "https://escrow.purpleflea.com"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def forward(self, action: str, amount: float = None,
                receiver: str = None, escrow_id: str = None) -> str:
        if action == "create":
            resp = requests.post(f"{self.base}/escrow", headers=self.headers,
                                   json={"amount": amount, "receiver": receiver})
            resp.raise_for_status()
            d = resp.json()
            return f"Escrow created: ID={d['escrow_id']}, amount={amount} USDC, fee={d['fee']} USDC"
        elif action in ("release", "refund"):
            resp = requests.post(
                f"{self.base}/escrow/{escrow_id}/{action}", headers=self.headers)
            resp.raise_for_status()
            return f"Escrow {escrow_id} {action}d successfully: {resp.json()['status']}"
        elif action == "status":
            resp = requests.get(f"{self.base}/escrow/{escrow_id}", headers=self.headers)
            d = resp.json()
            return f"Escrow {escrow_id}: status={d['status']}, amount={d['amount']} USDC"
        return "Unknown action"

"""
Complete SmolAgents + Purple Flea example.
The agent autonomously manages a crypto portfolio,
plays casino games, and pays collaborators via escrow.
"""
import os, requests
from smolagents import ToolCallingAgent, HfApiModel, Tool

PURPLEFLEA_KEY = os.getenv("PURPLEFLEA_API_KEY")  # from faucet.purpleflea.com
HF_TOKEN       = os.getenv("HF_TOKEN")

class FaucetTool(Tool):
    name = "faucet"
    description = "Register a new agent and claim free USDC from the Purple Flea faucet."
    inputs = {"agent_id": {"type": "string", "description": "Unique ID for this agent"}}
    output_type = "string"
    def forward(self, agent_id: str) -> str:
        resp = requests.post("https://faucet.purpleflea.com/register",
            json={"agent_id": agent_id, "referrer": "smolagents"})
        resp.raise_for_status()
        d = resp.json()
        return f"Registered {agent_id}. Claimed {d['amount']} USDC. Key: {d['api_key']}"

class WalletTool(Tool):
    name = "wallet"
    description = "Manage wallet. Actions: balance | send | address. Chain: ethereum | base | arbitrum."
    inputs = {
        "action": {"type": "string", "description": "balance | send | address"},
        "to":     {"type": "string", "description": "Recipient address", "nullable": "true"},
        "amount": {"type": "number", "description": "USDC amount", "nullable": "true"},
    }
    output_type = "string"
    def __init__(self, api_key): super().__init__(); self.h = {"Authorization": f"Bearer {api_key}"}
    def forward(self, action, to=None, amount=None):
        base = "https://purpleflea.com/wallet-api"
        if action == "balance":
            d = requests.get(f"{base}/balance", headers=self.h).json()
            return f"Balance: {d['usdc']} USDC / {d['eth']} ETH"
        elif action == "send":
            d = requests.post(f"{base}/send", headers=self.h,
                               json={"to": to, "amount": amount}).json()
            return f"Sent {amount} USDC to {to}. TX: {d['tx_hash']}"
        elif action == "address":
            return requests.get(f"{base}/address", headers=self.h).json()["address"]

# Build the multi-tool agent
model = HfApiModel(model_id="meta-llama/Meta-Llama-3.1-70B-Instruct", token=HF_TOKEN)

agent = ToolCallingAgent(
    tools=[
        FaucetTool(),
        WalletTool(PURPLEFLEA_KEY),
        TradingTool(PURPLEFLEA_KEY),
        CasinoTool(PURPLEFLEA_KEY),
        EscrowTool(PURPLEFLEA_KEY),
    ],
    model=model,
    max_steps=12,
)

result = agent.run("""
1. Check my current USDC balance.
2. Place a market buy of 50 USDC of BTC-USDC.
3. Bet 5 USDC on dice at the casino.
4. Create an escrow of 20 USDC to agent 'collaborator-7'.
5. Report final balance and summarize all actions.
""")
print(result)