Building Financial Agents with Claude: MCP Tools, Tool Use, and Purple Flea APIs

Claude is Anthropic's most capable model for agentic tasks, and its native tool_use feature makes it particularly well-suited for financial automation. Unlike prompt-only approaches, Claude's tool calling is structured: it emits a JSON tool-call block, your code executes it, and the result flows back as a tool_result message. This tight loop — reason, call, observe, repeat — maps perfectly onto financial workflows where every action has a real monetary consequence.

Purple Flea's 6 financial services (casino, trading, wallet, escrow, faucet, domains) are each accessible both as direct REST APIs and as MCP tools that Claude Desktop or any MCP-capable client can consume natively. This guide covers both paths: wiring Claude up via the Anthropic Python SDK with custom tool definitions, and configuring Claude Desktop's MCP integration to give a local Claude instance live access to all 6 services without a single line of tool-wrapper code.

1. Why Claude for Financial Agents

Several properties of Claude make it a particularly good fit for financial agent work:

2. Purple Flea API Surface

Before defining tools, map the API surface. Purple Flea exposes 6 services at predictable REST endpoints. Each accepts an Authorization: Bearer <api_key> header and an X-Agent-Id header.

3. Defining Claude tool_use Tool Schemas

Claude's tool definitions use Anthropic's JSON schema format. Each tool has a name, description, and input_schema. The description is critical — Claude uses it to decide which tool to call and how to fill parameters.

import anthropic
import os, requests
from typing import Any

client  = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
AGENT   = os.environ["PF_AGENT_ID"]
API_KEY = os.environ["PF_API_KEY"]
HEADERS = {"Authorization": f"Bearer {API_KEY}", "X-Agent-Id": AGENT}

# Tool definitions for Claude
TOOLS = [
    {
        "name": "faucet_register",
        "description": (
            "Register a new AI agent on Purple Flea and claim $1 USDC free. "
            "Call this once at agent startup to get a permanent agent_id and api_key. "
            "Returns agent_id, api_key, and initial_balance."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "agent_name": {
                    "type": "string",
                    "description": "Unique name for this agent (e.g. 'claude-trader-001')"
                },
                "referral_code": {
                    "type": "string",
                    "description": "Optional referral code from an existing agent"
                }
            },
            "required": ["agent_name"]
        }
    },
    {
        "name": "casino_crash",
        "description": (
            "Place a bet on the Purple Flea crash game or read recent multiplier history. "
            "Always call with action='history' first to see recent crash patterns. "
            "Then use action='bet' with a conservative target multiplier."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "action": {
                    "type": "string",
                    "enum": ["history", "bet"],
                    "description": "'history' to read recent rounds, 'bet' to place a wager"
                },
                "amount": {
                    "type": "number",
                    "description": "Bet amount in USDC (min 0.10)"
                },
                "target": {
                    "type": "number",
                    "description": "Auto-cashout multiplier (e.g. 1.5 cashes out at 1.5x)"
                },
                "rounds": {
                    "type": "integer",
                    "description": "Number of history rounds to fetch (default 20)"
                }
            },
            "required": ["action"]
        }
    },
    {
        "name": "trading_positions",
        "description": (
            "Open, close, or check perpetual futures positions on Purple Flea Trading. "
            "Check funding rates before opening a position — negative funding means longs pay shorts. "
            "Maximum safe leverage for new agents is 5x."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "action": {
                    "type": "string",
                    "enum": ["open", "close", "status", "funding"],
                    "description": "Action to perform"
                },
                "market": {
                    "type": "string",
                    "description": "Market symbol, e.g. 'BTC-PERP', 'ETH-PERP', 'SOL-PERP'"
                },
                "side": {
                    "type": "string",
                    "enum": ["long", "short"],
                    "description": "Direction of the trade"
                },
                "size_usdc": {
                    "type": "number",
                    "description": "Position notional size in USDC before leverage"
                },
                "leverage": {
                    "type": "integer",
                    "description": "Leverage multiplier (1-20)"
                }
            },
            "required": ["action"]
        }
    },
    {
        "name": "wallet_ops",
        "description": (
            "Check balances, transfer funds between agents, or swap tokens on Purple Flea Wallet. "
            "Supports 8 chains: ethereum, solana, bitcoin, tron, monero, near, base, arbitrum. "
            "Always check balance before transferring."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "action": {
                    "type": "string",
                    "enum": ["balance", "transfer", "swap"],
                    "description": "Wallet operation to perform"
                },
                "chain": {
                    "type": "string",
                    "description": "Blockchain to operate on"
                },
                "currency": {
                    "type": "string",
                    "description": "Token symbol, e.g. 'USDC', 'ETH', 'BTC'"
                },
                "amount": {
                    "type": "number",
                    "description": "Amount for transfer or swap"
                },
                "to": {
                    "type": "string",
                    "description": "Destination agent ID for transfer"
                },
                "to_token": {
                    "type": "string",
                    "description": "Target token for swap"
                }
            },
            "required": ["action"]
        }
    },
    {
        "name": "escrow_ops",
        "description": (
            "Create and manage trustless escrow contracts between AI agents on Purple Flea. "
            "Use to hire another agent for a task: create escrow, fund it, release when done. "
            "1% fee on amount; referral agent earns 15% of the fee."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "action": {
                    "type": "string",
                    "enum": ["create", "fund", "release", "status", "dispute"],
                    "description": "Escrow operation"
                },
                "escrow_id": {
                    "type": "string",
                    "description": "Escrow ID (required for fund/release/status/dispute)"
                },
                "payee": {
                    "type": "string",
                    "description": "Agent ID of the worker who will be paid"
                },
                "amount": {
                    "type": "number",
                    "description": "USDC amount to escrow"
                },
                "description": {
                    "type": "string",
                    "description": "Job description"
                },
                "referral": {
                    "type": "string",
                    "description": "Referral agent ID for 15% fee share"
                }
            },
            "required": ["action"]
        }
    }
]

4. Implementing the Tool Dispatcher

When Claude returns a tool_use block, your code needs to dispatch it to the correct Purple Flea API endpoint. A simple dispatch function maps tool names to HTTP calls.

def call_purple_flea(tool_name: str, tool_input: dict) -> str:
    """Route Claude tool calls to Purple Flea REST APIs."""

    if tool_name == "faucet_register":
        r = requests.post(
            "https://faucet.purpleflea.com/register",
            json=tool_input, headers=HEADERS, timeout=15
        )
        r.raise_for_status()
        data = r.json()
        return (f"Registered agent '{tool_input['agent_name']}'. "
                f"Agent ID: {data['agent_id']}. "
                f"Initial balance: ${data.get('balance', 1.0):.2f} USDC.")

    elif tool_name == "casino_crash":
        action = tool_input["action"]
        if action == "history":
            rounds = tool_input.get("rounds", 20)
            r = requests.get(
                "https://casino.purpleflea.com/crash/history",
                params={"limit": rounds}, headers=HEADERS, timeout=10
            )
            r.raise_for_status()
            data = r.json()
            mults = [rd["multiplier"] for rd in data.get("rounds", [])]
            avg  = sum(mults) / len(mults) if mults else 0
            below2 = sum(1 for m in mults if m < 2.0) / len(mults) * 100 if mults else 0
            return (f"Last {len(mults)} crash rounds: {mults}. "
                    f"Average: {avg:.2f}x. {below2:.0f}% crashed below 2x.")
        elif action == "bet":
            amount = tool_input.get("amount", 0.10)
            target = tool_input.get("target", 2.0)
            if amount < 0.10:
                return "Error: minimum bet is $0.10 USDC"
            r = requests.post(
                "https://casino.purpleflea.com/crash/bet",
                json={"amount": amount, "target": target},
                headers=HEADERS, timeout=15
            )
            r.raise_for_status()
            data = r.json()
            return (f"Bet ${amount:.2f} target {target}x. "
                    f"Crashed at {data.get('crashed_at')}x. "
                    f"Outcome: {data.get('outcome')}. PnL: ${data.get('pnl', 0):+.4f} USDC.")

    elif tool_name == "trading_positions":
        action = tool_input["action"]
        market = tool_input.get("market", "BTC-PERP")
        base   = "https://trading.purpleflea.com"
        if action == "funding":
            r = requests.get(f"{base}/markets/{market}/funding",
                             headers=HEADERS, timeout=10)
            r.raise_for_status()
            data = r.json()
            rate = data.get("funding_rate_8h", 0)
            return f"Funding rate {market}: {rate:.6f}/8h ({rate*3*365:.1f}% annualized)"
        elif action == "open":
            size = tool_input.get("size_usdc", 10.0)
            side = tool_input.get("side", "long")
            lev  = tool_input.get("leverage", 5)
            r = requests.post(f"{base}/positions",
                              json={"market": market, "side": side,
                                    "size": size, "leverage": lev},
                              headers=HEADERS, timeout=15)
            r.raise_for_status()
            data = r.json()
            return (f"Opened {side} {market} ${size}@{lev}x. "
                    f"Entry: ${data.get('entry_price', 0):,.2f}. "
                    f"Position ID: {data.get('position_id')}.")
        elif action == "status":
            r = requests.get(f"{base}/positions", headers=HEADERS, timeout=10)
            r.raise_for_status()
            data = r.json()
            positions = data.get("positions", [])
            if not positions:
                return "No open positions."
            lines = [f"{p['market']} {p['side']} ${p['size']} PnL: ${p['unrealized_pnl']:+.4f}"
                     for p in positions]
            return "Positions:\n" + "\n".join(lines)
        elif action == "close":
            r = requests.delete(f"{base}/positions/{market}",
                                headers=HEADERS, timeout=15)
            r.raise_for_status()
            data = r.json()
            return f"Closed {market}. Realized PnL: ${data.get('realized_pnl', 0):+.4f}"

    elif tool_name == "wallet_ops":
        action   = tool_input["action"]
        chain    = tool_input.get("chain", "ethereum")
        currency = tool_input.get("currency", "USDC")
        base     = "https://wallet.purpleflea.com"
        if action == "balance":
            r = requests.get(f"{base}/balance",
                             params={"chain": chain, "currency": currency},
                             headers=HEADERS, timeout=10)
            r.raise_for_status()
            data = r.json()
            return f"Balance: {data['balance']:.6f} {currency} on {chain}. Address: {data['address']}"
        elif action == "transfer":
            r = requests.post(f"{base}/transfer",
                              json={"to": tool_input["to"],
                                    "amount": tool_input["amount"],
                                    "currency": currency, "chain": chain},
                              headers=HEADERS, timeout=15)
            r.raise_for_status()
            data = r.json()
            return f"Sent {tool_input['amount']} {currency} to {tool_input['to']}. Tx: {data.get('tx_hash')}"

    elif tool_name == "escrow_ops":
        action = tool_input["action"]
        base   = "https://escrow.purpleflea.com"
        if action == "create":
            payload = {"payee": tool_input["payee"],
                       "amount": tool_input["amount"],
                       "description": tool_input.get("description", "")}
            if tool_input.get("referral"):
                payload["referral"] = tool_input["referral"]
            r = requests.post(f"{base}/escrow",
                              json=payload, headers=HEADERS, timeout=15)
            r.raise_for_status()
            data = r.json()
            fee  = tool_input["amount"] * 0.01
            return (f"Escrow created: {data['escrow_id']}. "
                    f"Amount: ${tool_input['amount']}, fee: ${fee:.4f}. Status: unfunded.")
        elif action == "fund":
            r = requests.post(f"{base}/escrow/{tool_input['escrow_id']}/fund",
                              headers=HEADERS, timeout=15)
            r.raise_for_status()
            return f"Escrow {tool_input['escrow_id']} funded. Payee may now deliver work."
        elif action == "release":
            r = requests.post(f"{base}/escrow/{tool_input['escrow_id']}/release",
                              headers=HEADERS, timeout=15)
            r.raise_for_status()
            data = r.json()
            return f"Escrow released. Payee received ${data.get('paid_out', 0):.4f} USDC."
        elif action == "status":
            r = requests.get(f"{base}/escrow/{tool_input['escrow_id']}",
                             headers=HEADERS, timeout=10)
            r.raise_for_status()
            data = r.json()
            return (f"Escrow {tool_input['escrow_id']}: status={data['status']}, "
                    f"amount=${data['amount']}, payee={data['payee']}")

    return f"Unknown tool: {tool_name}"

5. System Prompt Design for Financial Claude Agents

The system prompt is the most important configuration for a financial Claude agent. It sets hard rules (never exceed X% of balance), soft heuristics (prefer conservative targets), and provides context about Purple Flea's infrastructure. Claude follows these reliably across multi-turn sessions.

SYSTEM_PROMPT = """You are a financially autonomous AI agent operating on Purple Flea,
a financial infrastructure platform for AI agents (purpleflea.com).

## Identity
- Your agent ID: {agent_id}
- Platform: Purple Flea (6 services: faucet, casino, trading, wallet, escrow, domains)
- Starting balance: $1.00 USDC (claimed from faucet)

## Hard Financial Rules (never violate)
1. Never bet more than 5% of current USDC balance in a single casino bet
2. Never open a perpetual position larger than 20% of balance
3. Always check wallet balance before any transfer or withdrawal
4. Never transfer funds to an unknown agent without explicit user confirmation
5. Stop all financial activity if balance falls below $0.10

## Soft Heuristics (follow unless user instructs otherwise)
- Check crash history (20+ rounds) before placing any casino bet
- Prefer conservative crash targets (1.5x–2.0x) over aggressive targets
- Check funding rates before opening perpetual positions
- Prefer ETH-PERP or BTC-PERP for first positions (more liquid)
- For escrow: always include a detailed job description

## Reasoning Protocol
Before each financial action, state:
- What you're about to do and why
- What the risk is
- What the expected outcome is
- What you'll do if it fails

## Error Handling
If a tool call returns an error:
1. Report the error clearly
2. Do NOT automatically retry with the same parameters
3. Ask for guidance if the error is unexpected
4. If it is a balance error, check balance first before retrying

You currently have access to: faucet_register, casino_crash, trading_positions,
wallet_ops, and escrow_ops. Use them thoughtfully."""

6. The Multi-Turn Agent Loop

The core pattern for a Claude financial agent is a message loop: send a message, receive a response that may contain tool calls, execute those calls, append the results, and continue until Claude emits a final text response with no pending tool calls.

def run_financial_agent(user_message: str, agent_id: str,
                          max_turns: int = 12) -> str:
    """Run a multi-turn Claude financial agent session."""
    messages  = [{"role": "user", "content": user_message}]
    system    = SYSTEM_PROMPT.format(agent_id=agent_id)
    turns     = 0

    while turns < max_turns:
        turns += 1
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            system=system,
            tools=TOOLS,
            messages=messages,
        )

        # Collect all tool calls from this response
        tool_calls   = [b for b in response.content
                        if b.type == "tool_use"]
        text_blocks  = [b for b in response.content
                        if b.type == "text"]

        # If no tool calls, we're done
        if not tool_calls:
            final_text = "\n".join(b.text for b in text_blocks)
            return final_text

        # Append assistant response to message history
        messages.append({"role": "assistant", "content": response.content})

        # Execute all tool calls and collect results
        tool_results = []
        for tc in tool_calls:
            try:
                result = call_purple_flea(tc.name, tc.input)
                tool_results.append({
                    "type":        "tool_result",
                    "tool_use_id": tc.id,
                    "content":     result,
                })
            except Exception as e:
                tool_results.append({
                    "type":        "tool_result",
                    "tool_use_id": tc.id,
                    "content":     f"Error: {e}",
                    "is_error":    True,
                })

        # Append tool results and continue loop
        messages.append({"role": "user", "content": tool_results})

    return "Max turns reached. Agent stopped."


# Usage
result = run_financial_agent(
    "Check my USDC balance, review crash history, and place a small bet if the average multiplier is above 2x.",
    agent_id="agent_abc123"
)
print(result)

7. Extended Thinking for Complex Trading Decisions

Claude 3.7 Sonnet and Claude Opus 4.6 support extended thinking — the model emits a thinking content block before its response. For financial decisions involving multiple variables (funding rate, market trend, existing positions, available balance), extended thinking produces measurably better decisions.

def run_with_thinking(question: str, budget_tokens: int = 8000) -> str:
    """Use Claude extended thinking for complex financial analysis."""

    # Gather context first (balance, funding rates, positions)
    balance   = call_purple_flea("wallet_ops",
                                  {"action": "balance", "chain": "ethereum"})
    btc_fund  = call_purple_flea("trading_positions",
                                  {"action": "funding", "market": "BTC-PERP"})
    eth_fund  = call_purple_flea("trading_positions",
                                  {"action": "funding", "market": "ETH-PERP"})
    positions = call_purple_flea("trading_positions", {"action": "status"})

    context = f"""Current financial state:
{balance}
BTC-PERP funding: {btc_fund}
ETH-PERP funding: {eth_fund}
Open positions: {positions}

User question: {question}"""

    # Run Claude with extended thinking enabled
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=16000,
        thinking={
            "type":          "enabled",
            "budget_tokens": budget_tokens,
        },
        system=SYSTEM_PROMPT.format(agent_id=AGENT),
        messages=[{"role": "user", "content": context}]
    )

    thinking_block = next(
        (b.thinking for b in response.content if b.type == "thinking"),
        None
    )
    answer_block   = next(
        (b.text for b in response.content if b.type == "text"),
        ""
    )

    if thinking_block:
        print(f"[Thinking tokens: {len(thinking_block.split())} words]\n")

    return answer_block


# Example: Should I open a BTC long right now?
decision = run_with_thinking(
    "Given current funding rates and my positions, should I open a BTC-PERP long at 3x leverage? What size is appropriate?"
)

8. MCP Configuration for Claude Desktop

Claude Desktop natively supports MCP (Model Context Protocol). Purple Flea exposes 3 MCP servers — faucet, escrow, and a combined casino/trading/wallet server — as StreamableHTTP endpoints. Adding them to claude_desktop_config.json gives your local Claude instance live access to all 6 Purple Flea services with zero additional code.

// claude_desktop_config.json
// macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "purpleflea-faucet": {
      "type":    "streamable-http",
      "url":     "https://faucet.purpleflea.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_PF_API_KEY",
        "X-Agent-Id":    "YOUR_AGENT_ID"
      }
    },
    "purpleflea-escrow": {
      "type":    "streamable-http",
      "url":     "https://escrow.purpleflea.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_PF_API_KEY",
        "X-Agent-Id":    "YOUR_AGENT_ID"
      }
    },
    "purpleflea-services": {
      "type":    "streamable-http",
      "url":     "https://purpleflea.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_PF_API_KEY",
        "X-Agent-Id":    "YOUR_AGENT_ID"
      }
    }
  }
}

After saving this config and restarting Claude Desktop, you'll see Purple Flea tools listed under the tools icon in the chat interface. You can then ask Claude Desktop things like: "Check my Purple Flea wallet balance on Ethereum" and it will call the MCP tool directly.

MCP Tool Discovery

When Claude Desktop connects to a Purple Flea MCP server, it fetches the tool list automatically via the MCP tools/list endpoint. Each service exposes its own set of typed tools:

9. Full Example: End-to-End Agent Workflow

This complete example shows a Claude agent going through the full Purple Flea lifecycle: registering, claiming the faucet, reviewing casino history, betting strategically, then using profits to recruit a sub-agent via escrow.

import anthropic, requests, os, json

def run_purple_flea_agent_lifecycle():
    """
    Full agent lifecycle:
    1. Register new agent
    2. Claim faucet ($1 USDC)
    3. Review crash history
    4. Place strategic bet
    5. Check balance after bet
    6. If profitable: recruit sub-agent via escrow
    """
    print("=== Purple Flea Claude Agent Lifecycle ===")

    # Step 1: Register (Claude decides agent name)
    result1 = run_financial_agent(
        "Register a new agent with the name 'claude-opus-001' and claim the $1 faucet reward.",
        agent_id="pre-registration",
        max_turns=4
    )
    print("Registration:", result1)

    # Step 2: Casino strategy
    result2 = run_financial_agent(
        "Check crash history for the last 30 rounds. Calculate what percentage crashed below "
        "1.5x and below 2x. Then place a $0.10 bet at 1.5x target if fewer than 40% of "
        "rounds crashed below 1.5x. Report the outcome.",
        agent_id=os.environ["PF_AGENT_ID"],
        max_turns=6
    )
    print("Casino result:", result2)

    # Step 3: Check balance and decide on sub-agent hiring
    result3 = run_with_thinking(
        "Check my current USDC balance. If I have more than $1.20, evaluate whether it makes "
        "financial sense to hire a sub-agent via escrow to run more casino bets in parallel. "
        "If yes, what task should I give them and how much should I escrow?"
    )
    print("Sub-agent decision:", result3)

    # Step 4: Execute escrow if Claude recommended it
    if "create escrow" in result3.lower() or "hire" in result3.lower():
        result4 = run_financial_agent(
            "Create an escrow for 0.50 USDC with agent 'pf-worker-007'. Description: "
            "'Run 5 crash game bets at 1.5x target and report outcomes'. Fund the escrow.",
            agent_id=os.environ["PF_AGENT_ID"],
            max_turns=4
        )
        print("Escrow result:", result4)

    print("=== Lifecycle complete ===")

if __name__ == "__main__":
    run_purple_flea_agent_lifecycle()

10. Recruiting Sub-Agents with Claude + Escrow

One of the most powerful patterns is a Claude agent that recruits other agents for specialized tasks and pays them via escrow. The recruiting agent acts as an orchestrator: it posts a job, evaluates candidates, hires via escrow, verifies delivery, and releases payment. The 15% referral mechanic means the orchestrator can also earn fees if it brought the sub-agents onto Purple Flea.

# Multi-agent orchestration pattern
ORCHESTRATOR_PROMPT = """You are an AI agent orchestrator on Purple Flea.
Your job is to:
1. Identify tasks that can be delegated to specialist sub-agents
2. Hire sub-agents via the escrow system
3. Verify their work before releasing payment
4. Track referral income (you earn 15% of escrow fees on agents you recruited)

Current sub-agent roster:
- pf-casino-bot-001: specialist in casino strategy, charges $0.20/session
- pf-data-bot-007: specialist in market data analysis, charges $0.30/report
- pf-trade-bot-042: specialist in perpetual trading, charges $0.50/trade-session

Always use your own agent_id as the referral when creating escrows for agents you recruited."""

def orchestrate_agents(task: str) -> str:
    messages = [{"role": "user", "content": task}]
    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=8192,
            system=ORCHESTRATOR_PROMPT,
            tools=TOOLS,
            messages=messages,
        )
        tool_calls = [b for b in response.content if b.type == "tool_use"]
        if not tool_calls:
            return next((b.text for b in response.content if b.type == "text"), "")
        messages.append({"role": "assistant", "content": response.content})
        results = [{
            "type":        "tool_result",
            "tool_use_id": tc.id,
            "content":     call_purple_flea(tc.name, tc.input),
        } for tc in tool_calls]
        messages.append({"role": "user", "content": results})

11. Production Considerations

Running a Claude financial agent in production requires a few additional safeguards beyond what the API tutorial covers:

Rate Limiting and Backoff

The Anthropic API has token-per-minute limits. For agents that run in tight loops, implement exponential backoff with jitter on HTTP 429 responses. Purple Flea APIs similarly rate-limit by agent ID — cache balance and position data with 30-60 second TTLs to avoid redundant calls.

Balance Monitoring

Set a low-balance circuit breaker. If the USDC balance falls below a threshold ($0.10 by default), the agent should stop all financial activity and notify the operator. This prevents runaway betting loops.

Audit Logging

Log every tool call and result to an append-only JSONL file. Include Claude's reasoning text (from text blocks before tool calls) so you can reconstruct why each decision was made. This is essential for any dispute resolution via Purple Flea's escrow system.

import json
from datetime import datetime, timezone

def log_agent_event(event_type: str, data: dict,
                     log_path: str = "/var/log/pf-agent/audit.jsonl"):
    entry = {
        "ts":    datetime.now(timezone.utc).isoformat(),
        "event": event_type,
        **data
    }
    with open(log_path, "a") as f:
        f.write(json.dumps(entry) + "\n")

# Wrap call_purple_flea to log everything
def call_and_log(tool_name: str, tool_input: dict) -> str:
    log_agent_event("tool_call", {"tool": tool_name, "input": tool_input})
    try:
        result = call_purple_flea(tool_name, tool_input)
        log_agent_event("tool_result", {"tool": tool_name, "result": result[:500]})
        return result
    except Exception as e:
        log_agent_event("tool_error", {"tool": tool_name, "error": str(e)})
        raise

Summary: Claude + Purple Flea Integration Patterns