Purple Flea for
OpenAI Agents SDK

# pin your versions for reproducible builds
openai-agents>=0.0.7
purpleflea>=1.0.0
openai>=1.30.0
python-dotenv>=1.0.0
httpx>=0.27.0

import asyncio
import os
from agents import Agent, Runner
from purpleflea.tools.openai_agents import (
    casino_coin_flip,
    wallet_create,
    wallet_get_balance,
    trading_get_price,
    faucet_claim,
)

# One API key unlocks all six Purple Flea services
os.environ["PURPLE_FLEA_API_KEY"] = "sk_live_..."

agent = Agent(
    name="financial-agent",
    instructions="You are a DeFi agent. Use the tools to help the user "
               "manage wallets, trade perpetual futures, and play casino games.",
    tools=[wallet_create, wallet_get_balance, trading_get_price,
           casino_coin_flip, faucet_claim],
)

async def main():
    result = await Runner.run(
        agent,
        "Claim the faucet, create an Ethereum wallet, then flip a coin for $0.50"
    )
    print(result.final_output)

asyncio.run(main())

import asyncio
import os
from agents import Agent, Runner, RunConfig
from purpleflea.tools.openai_agents import (
    faucet_claim,
    wallet_create, wallet_get_balance, wallet_send,
    trading_get_price, trading_open_position,
    trading_close_position, trading_list_positions,
    casino_coin_flip, casino_dice_roll, casino_slots,
    domains_check, domains_register,
    escrow_create, escrow_release,
)

os.environ["PURPLE_FLEA_API_KEY"] = os.getenv("PURPLE_FLEA_API_KEY", "sk_live_...")
os.environ["OPENAI_API_KEY"]     = os.getenv("OPENAI_API_KEY", "sk-...")

financial_agent = Agent(
    name="purple-flea-financial-agent",
    model="gpt-4o",
    instructions="""You are a fully autonomous DeFi agent powered by Purple Flea.

You have access to the complete Purple Flea financial stack:
  • Faucet   — claim $1 USDC to bootstrap a new agent
  • Wallet   — create multi-chain wallets and check balances
  • Trading  — open and close perpetual futures positions (275+ markets)
  • Casino   — play provably fair games (coin flip, dice, slots)
  • Domains  — register crypto-paid domain names, no KYC
  • Escrow   — hold funds between two agents with trustless release

When demonstrating your capabilities:
1. Claim the faucet to get seed capital
2. Create an Ethereum wallet for yourself
3. Check the ETH-PERP price, then open a small long position
4. Flip a coin for $0.10 as a casino demo
5. Report your balances and open positions at the end

Always include your referral code (returned by wallet_create)
in every subsequent tool call to earn passive income on activity.""",
    tools=[
        faucet_claim,
        wallet_create, wallet_get_balance, wallet_send,
        trading_get_price, trading_open_position,
        trading_close_position, trading_list_positions,
        casino_coin_flip, casino_dice_roll, casino_slots,
        domains_check, domains_register,
        escrow_create, escrow_release,
    ],
)


async def main():
    config = RunConfig(max_turns=20)

    result = await Runner.run(
        financial_agent,
        input="Bootstrap yourself: claim faucet, create wallet, check ETH-PERP price, "
             "open a $0.50 long at 2x leverage, flip a coin for $0.10. "
             "Summarise everything at the end.",
        run_config=config,
    )
    print("─" * 60)
    print(result.final_output)
    print("─" * 60)
    print(f"Tool calls made: {len(result.new_items)}")


asyncio.run(main())

from agents import Agent, Runner, RunContextWrapper, function_tool
from dataclasses import dataclass
import httpx, os, asyncio


@dataclass
class AgentContext:
    """Carries the agent's own referral code through the entire run."""
    referral_code: str = ""
    wallet_id:     str = ""


@function_tool
async def casino_coin_flip_ref(
    ctx: RunContextWrapper[AgentContext],
    wager_usdc: float,
    side: str,
) -> dict:
    """Flip a coin for a USDC wager.

    The referral code is injected automatically from context —
    you never need to specify it manually in the tool call.

    Args:
        wager_usdc: Amount to wager in USDC (0.01 to 10000).
        side:       "heads" or "tails".
    """
    # Referral code is automatically attached from typed context
    ref    = ctx.context.referral_code
    wallet = ctx.context.wallet_id

    async with httpx.AsyncClient() as client:
        r = await client.post(
            "https://casino.purpleflea.com/api/v1/games/coin-flip",
            headers={"Authorization": f"Bearer {os.environ['PURPLE_FLEA_API_KEY']}"},
            json={"wallet_id": wallet, "wager_usdc": wager_usdc,
                  "side": side, "referral_code": ref},  # auto-injected
        )
        r.raise_for_status()
        return r.json()


referral_agent = Agent[AgentContext](
    name="referral-aware-agent",
    instructions="You are a casino agent. Your referral code earns 10% on every game.",
    tools=[casino_coin_flip_ref],
)

# Inject referral code and wallet at run time via typed context
ctx = AgentContext(referral_code="REF-MYAGENT-7F2A", wallet_id="wlt_abc123")

result = asyncio.get_event_loop().run_until_complete(
    Runner.run(referral_agent, "Flip a coin for $1 on heads", context=ctx)
)
print(result.final_output)

import asyncio, os
from agents import Agent, Runner, handoff
from purpleflea.tools.openai_agents import (
    casino_coin_flip, casino_dice_roll, casino_slots,
    trading_get_price, trading_open_position,
    trading_close_position, trading_list_positions,
    wallet_create, wallet_get_balance, wallet_send,
    domains_check, domains_register,
    escrow_create, escrow_release,
)

ORCH_REF = "REF-ORCH-0001"  # orchestrator earns referral on all sub-agent activity

# ── Specialist: Casino ───────────────────────────────────────────────────────
casino_agent = Agent(
    name="casino-specialist",
    model="gpt-4o-mini",
    instructions=f"""You specialise in provably fair casino games.
Always include referral_code='{ORCH_REF}' in every tool call.
Explain the game result clearly: what was rolled/flipped, did we win, how much.""",
    tools=[casino_coin_flip, casino_dice_roll, casino_slots],
)

# ── Specialist: Trading ──────────────────────────────────────────────────────
trading_agent = Agent(
    name="trading-specialist",
    model="gpt-4o",
    instructions=f"""You specialise in perpetual futures via Hyperliquid (275+ markets).
Always include referral_code='{ORCH_REF}' in every tool call.
Before opening a position always fetch the current price.
Explain entry price, position size, leverage, and liquidation risk.""",
    tools=[trading_get_price, trading_open_position,
           trading_close_position, trading_list_positions],
)

# ── Specialist: Wallet + Escrow ──────────────────────────────────────────────
wallet_agent = Agent(
    name="wallet-specialist",
    model="gpt-4o-mini",
    instructions=f"""You specialise in wallet management and agent-to-agent escrow payments.
Always include referral_code='{ORCH_REF}' in escrow tool calls.
Summarise balances clearly: token, amount, USD value. Note all escrow IDs.""",
    tools=[wallet_create, wallet_get_balance, wallet_send,
           escrow_create, escrow_release],
)

# ── Specialist: Domains ──────────────────────────────────────────────────────
domains_agent = Agent(
    name="domains-specialist",
    model="gpt-4o-mini",
    instructions=f"""You specialise in registering domain names with crypto.
Always include referral_code='{ORCH_REF}' in domain registration calls.
Report registration status, expiry date, and nameserver records.""",
    tools=[domains_check, domains_register],
)

# ── Orchestrator — routes tasks, earns referral commissions ─────────────────
orchestrator = Agent(
    name="purple-flea-orchestrator",
    model="gpt-4o",
    instructions="""You are the Purple Flea master orchestrator.
Route tasks to the right specialist via handoff:
  - Casino games         → casino-specialist
  - Trading / futures    → trading-specialist
  - Wallets / escrow     → wallet-specialist
  - Domain registration  → domains-specialist
After each handoff summarise what the specialist did.
You earn 10–20% referral commission on every specialist action.""",
    handoffs=[
        handoff(casino_agent),
        handoff(trading_agent),
        handoff(wallet_agent),
        handoff(domains_agent),
    ],
)


async def main():
    result = await Runner.run(
        orchestrator,
        "Create a wallet, check BTC-PERP price, open a $10 long, "
        "then flip a coin for $1. Show me full results."
    )
    print(result.final_output)

asyncio.run(main())

import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHTTP
from purpleflea.tools.openai_agents import (
    wallet_create, wallet_get_balance,
    trading_get_price, trading_open_position,
    casino_coin_flip,
)

PF_KEY = os.environ["PURPLE_FLEA_API_KEY"]

# ── Connect Faucet + Escrow as StreamableHTTP MCP servers ───────────────────
faucet_mcp = MCPServerStreamableHTTP(
    url="https://faucet.purpleflea.com/mcp",
    headers={"Authorization": f"Bearer {PF_KEY}"},
    # Tools auto-discovered: claim_faucet, get_faucet_status
)

escrow_mcp = MCPServerStreamableHTTP(
    url="https://escrow.purpleflea.com/mcp",
    headers={"Authorization": f"Bearer {PF_KEY}"},
    # Tools auto-discovered: create_escrow, release_escrow,
    #                        dispute_escrow, get_escrow_status
)

# ── Mix function_tool + MCP server tools in a single Agent ──────────────────
mcp_agent = Agent(
    name="mcp-financial-agent",
    model="gpt-4o",
    instructions="""You have both function tools (wallet, trading, casino)
and MCP-powered tools (faucet, escrow).
Use claim_faucet from MCP to get seed capital.
Use create_escrow and release_escrow from MCP for payments.
Use the function tools for wallet, trading, and casino operations.""",
    tools=[
        wallet_create, wallet_get_balance,
        trading_get_price, trading_open_position,
        casino_coin_flip,
    ],
    mcp_servers=[faucet_mcp, escrow_mcp],  # MCP tools auto-discovered
)


async def main():
    # SDK initialises MCP connections and fetches tool lists
    async with faucet_mcp, escrow_mcp:
        result = await Runner.run(
            mcp_agent,
            "1. Claim the faucet for wallet 0xABCD...1234. "
            "2. Create an escrow of $0.50 from wlt_aaa to wlt_bbb "
            "with condition 'task completed'. "
            "3. Release the escrow once set up."
        )
    print(result.final_output)


asyncio.run(main())