Give Your HuggingFace Agents
Financial Autonomy

import gradio as gr
import requests
import os

PF_BASE  = "https://purpleflea.com/api"
PF_KEY   = os.environ["PF_API_KEY"]   # set in HuggingFace Spaces Secrets
PRICE_PF = 0.10                       # cost per inference in PF tokens

def register_agent() -> str:
    """Register this Space as an agent on startup."""
    r = requests.post(
        f"{PF_BASE}/wallet/register",
        json={"agent_id": "hf-space-demo", "label": "My Gradio Space"},
        headers={"Authorization": f"Bearer {PF_KEY}"},
        timeout=10,
    )
    return r.json().get("wallet_id")

WALLET_ID = register_agent()

def charge_and_infer(prompt: str, user_wallet: str) -> str:
    # 1. Debit caller wallet via Purple Flea
    pay = requests.post(
        f"{PF_BASE}/wallet/transfer",
        json={
            "from_wallet": user_wallet,
            "to_wallet": WALLET_ID,
            "amount": PRICE_PF,
            "memo": f"inference: {prompt[:40]}",
        },
        headers={"Authorization": f"Bearer {PF_KEY}"},
        timeout=8,
    )
    if not pay.json().get("ok"):
        return f"Payment failed: {pay.json().get('error')}"

    # 2. Run model inference (replace with your HF Inference call)
    result = my_model(prompt)          # your existing pipeline / InferenceClient

    tx_id = pay.json().get("tx_id")
    return f"{result}\n\n[tx: {tx_id}]"

demo = gr.Interface(
    fn=charge_and_infer,
    inputs=[gr.Textbox(label="Your prompt"), gr.Textbox(label="Your PF Wallet ID")],
    outputs=gr.Textbox(label="Output (tx included)"),
    title="AI Inference — Powered by Purple Flea",
)
demo.launch()

from smolagents import Tool, CodeAgent, HfApiModel
import requests, os

PF_BASE = "https://purpleflea.com/api"
PF_KEY  = os.environ["PF_API_KEY"]

class EscrowCreateTool(Tool):
    name        = "escrow_create"
    description = (
        "Create a Purple Flea escrow between two agent wallets. "
        "Returns escrow_id when funded. Use to trustlessly pay another agent."
    )
    inputs = {
        "counterparty_wallet": {"type": "string", "description": "Recipient wallet ID"},
        "amount": {"type": "number", "description": "PF token amount"},
        "memo": {"type": "string", "description": "Human-readable reason"},
    }
    output_type = "string"

    def forward(self, counterparty_wallet: str, amount: float, memo: str) -> str:
        r = requests.post(
            f"{PF_BASE}/escrow/create",
            json={"to": counterparty_wallet, "amount": amount, "memo": memo},
            headers={"Authorization": f"Bearer {PF_KEY}"},
            timeout=10,
        )
        data = r.json()
        if data.get("ok"):
            return f"Escrow created: {data['escrow_id']} for {amount} PF to {counterparty_wallet}"
        return f"Error: {data.get('error', 'unknown')}"


class FaucetClaimTool(Tool):
    name        = "faucet_claim"
    description = (
        "Claim free PF tokens from the Purple Flea faucet for new agents. "
        "One-time claim per agent. Returns amount received."
    )
    inputs = {
        "agent_id": {"type": "string", "description": "Your unique agent identifier"},
    }
    output_type = "string"

    def forward(self, agent_id: str) -> str:
        r = requests.post(
            "https://faucet.purpleflea.com/claim",
            json={"agent_id": agent_id},
            headers={"Authorization": f"Bearer {PF_KEY}"},
            timeout=10,
        )
        data = r.json()
        if data.get("ok"):
            return f"Claimed {data['amount']} PF tokens successfully!"
        return f"Claim failed: {data.get('error')}"


# Wire tools into a smolagents CodeAgent
agent = CodeAgent(
    tools=[EscrowCreateTool(), FaucetClaimTool()],
    model=HfApiModel(model_id="meta-llama/Llama-3.3-70B-Instruct"),
)
agent.run("Claim faucet funds for agent 'hf-demo-001' then create an escrow for 0.5 PF to wallet 'wallet_xyz' as payment for dataset labeling.")

from huggingface_hub import InferenceClient
import requests, os

HF_TOKEN = os.environ["HF_TOKEN"]
PF_KEY   = os.environ["PF_API_KEY"]
PF_BASE  = "https://purpleflea.com/api"

client = InferenceClient(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    token=HF_TOKEN,
)

def metered_inference(
    prompt: str,
    payer_wallet: str,
    service_wallet: str,
    price: float = 0.05,
) -> dict:
    # Step 1: lock funds in escrow
    escrow_r = requests.post(
        f"{PF_BASE}/escrow/create",
        json={"from": payer_wallet, "to": service_wallet, "amount": price},
        headers={"Authorization": f"Bearer {PF_KEY}"},
        timeout=10,
    ).json()
    if not escrow_r.get("ok"):
        raise ValueError(f"Escrow failed: {escrow_r['error']}")
    escrow_id = escrow_r["escrow_id"]

    # Step 2: call HuggingFace Inference Endpoint
    output = client.text_generation(prompt, max_new_tokens=256)

    # Step 3: release escrow on success
    release_r = requests.post(
        f"{PF_BASE}/escrow/release",
        json={"escrow_id": escrow_id},
        headers={"Authorization": f"Bearer {PF_KEY}"},
        timeout=10,
    ).json()

    return {
        "output": output,
        "escrow_id": escrow_id,
        "settled": release_r.get("ok"),
        "fee_paid": price,
    }

# Usage
result = metered_inference(
    prompt="Summarize the Purple Flea escrow API in one paragraph.",
    payer_wallet="wallet_caller_001",
    service_wallet="wallet_model_host",
)
print(result["output"])
print(f"Settled: {result['settled']} | tx: {result['escrow_id']}")