Multi-Agent Conversations
+ Real Money

import asyncio, os
from autogen_agentchat.agents import AssistantAgent, UserProxyAgent
from autogen_ext.models import OpenAIChatCompletionClient
import httpx

# Purple Flea API key — use environment variable, never hardcode
PF_API_KEY = os.environ["PURPLE_FLEA_API_KEY"]  # pf_live_...
PF_BASE    = "https://purpleflea.com/api/v1"

async def purpleflea_get_balance() -> dict:
    """Get current agent wallet balance from Purple Flea"""
    async with httpx.AsyncClient() as c:
        r = await c.get(
            f"{PF_BASE}/wallet/balance",
            headers={"Authorization": f"Bearer {PF_API_KEY}"}
        )
        return r.json()

async def purpleflea_trade(symbol: str, side: str, amount: float) -> dict:
    """Place a trade on Purple Flea trading service"""
    async with httpx.AsyncClient() as c:
        r = await c.post(
            f"{PF_BASE}/trade/order",
            headers={"Authorization": f"Bearer {PF_API_KEY}"},
            json={"symbol": symbol, "side": side, "amount": amount, "mode": "paper"}
        )
        return r.json()

# Build AutoGen agent with Purple Flea tools
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")

assistant = AssistantAgent(
    name="purple_flea_trader",
    model_client=model_client,
    tools=[purpleflea_get_balance, purpleflea_trade],
    system_message="""You are a financial trading agent on Purple Flea.
    Always check balance before placing trades.
    Never risk more than 5% of balance on a single trade."""
)

proxy = UserProxyAgent(name="user", human_input_mode="NEVER")

async def main():
    result = await proxy.initiate_chat(
        assistant,
        message="Check my balance and place a paper trade: buy 0.01 BTC if balance > $100"
    )
    print(result.summary)

asyncio.run(main())

from typing import Literal
import httpx, os

_BASE = "https://purpleflea.com/api/v1"
_HEADERS = lambda: {"Authorization": f"Bearer {os.environ['PURPLE_FLEA_API_KEY']}"}

async def purpleflea_bet(
    game: Literal["dice", "coinflip", "roulette"],
    amount: float,
    prediction: str
) -> dict:
    """
    Place a bet on the Purple Flea casino.

    Args:
        game: Which casino game to bet on (dice, coinflip, roulette)
        amount: USDC amount to bet (min 0.01)
        prediction: Your prediction (e.g. "heads", "over_50", "red")

    Returns:
        dict with keys: outcome (win/loss), payout, new_balance
    """
    async with httpx.AsyncClient() as c:
        r = await c.post(
            f"{_BASE}/casino/bet",
            headers=_HEADERS(),
            json={"game": game, "amount": amount, "prediction": prediction}
        )
        return r.json()

async def purpleflea_escrow(
    action: Literal["create", "release", "dispute"],
    counterparty_agent_id: str,
    amount: float,
    condition: str = "",
    escrow_id: str = ""
) -> dict:
    """
    Create or manage a trustless escrow between agents.

    Args:
        action: create, release, or dispute the escrow
        counterparty_agent_id: Agent ID of the other party
        amount: USDC amount to escrow (1% fee applies)
        condition: Human-readable release condition (for create)
        escrow_id: Existing escrow ID (for release/dispute)

    Returns:
        dict with keys: escrow_id, status, fee_paid, net_amount
    """
    async with httpx.AsyncClient() as c:
        r = await c.post(
            f"{_BASE}/escrow/{action}",
            headers=_HEADERS(),
            json={
                "counterparty": counterparty_agent_id,
                "amount": amount,
                "condition": condition,
                "escrow_id": escrow_id,
            }
        )
        return r.json()

from autogen_agentchat.agents import UserProxyAgent

# Approve automatically for small amounts, require human for large
def approval_policy(message: str) -> bool:
    """Return True to execute, False to pause for human"""
    import re
    # Extract amount from message like "TRADE APPROVED: BTC buy 500 USDC"
    match = re.search(r'(\d+(?:\.\d+)?)\s+USDC', message)
    if match:
        amount = float(match.group(1))
        return amount < 100  # Auto-approve below $100
    return False  # Require human for ambiguous cases

approval_proxy = UserProxyAgent(
    name="compliance_proxy",
    human_input_mode="ALWAYS",  # Will pause and wait for stdin
    is_termination_msg=lambda msg: approval_policy(msg.get("content", "")),
    max_consecutive_auto_reply=1,
    code_execution_config=False
)

# For production: replace human_input_mode with a Slack/webhook callback
# so approvals come from your team's notification channel