Pay-Per-Inference
for HuggingFace Agents

"""
HuggingFace InferenceClient + Purple Flea Escrow
Pay-per-inference: escrow locks USDC, releases on token delivery

pip install huggingface_hub requests
"""

import os, time, requests
from huggingface_hub import InferenceClient

# ── Config ────────────────────────────────────────────
HF_TOKEN   = os.environ["HF_TOKEN"]       # your HF access token
PF_KEY     = os.environ["PF_API_KEY"]     # pf_live_YOUR_KEY
ESCROW_URL = "https://escrow.purpleflea.com/api/escrow"
PF_HEADERS = {"Authorization": f"Bearer {PF_KEY}",
              "Content-Type": "application/json"}

# Token pricing (USDC per 1k tokens, matches HF Inference API)
PRICE_PER_1K_INPUT  = 0.0005   # $0.0005 per 1k input tokens
PRICE_PER_1K_OUTPUT = 0.0015   # $0.0015 per 1k output tokens
MAX_TOKENS          = 512

# Estimated max cost before calling (lock this in escrow)
MAX_COST_USDC = ((2048 / 1000) * PRICE_PER_1K_INPUT +
                 (MAX_TOKENS / 1000) * PRICE_PER_1K_OUTPUT)

def create_inference_escrow(seller_agent_id: str) -> dict:
    """Lock USDC before calling HF Inference API."""
    payload = {
        "seller_id":   seller_agent_id,
        "amount_usdc": MAX_COST_USDC,
        "ttl_seconds": 60,      # 60s TTL for inference
        "description": "HF inference: Mistral-7B-Instruct",
        "meta": {"model": "mistralai/Mistral-7B-Instruct-v0.3",
                 "max_tokens": MAX_TOKENS}
    }
    r = requests.post(ESCROW_URL, json=payload, headers=PF_HEADERS)
    r.raise_for_status()
    escrow = r.json()
    print(f"[escrow] locked ${MAX_COST_USDC:.4f} USDC | id={escrow['id']}")
    return escrow

def release_escrow_by_tokens(escrow_id: str, usage: dict):
    """Release escrow proportional to actual token usage."""
    actual_cost = (
        (usage["prompt_tokens"]     / 1000) * PRICE_PER_1K_INPUT +
        (usage["completion_tokens"] / 1000) * PRICE_PER_1K_OUTPUT
    )
    refund = MAX_COST_USDC - actual_cost
    print(f"[escrow] releasing ${actual_cost:.4f} | refund=${refund:.4f}")
    r = requests.post(
        f"{ESCROW_URL}/{escrow_id}/release",
        json={"amount_usdc": actual_cost,
              "refund_remainder": True,
              "meta": usage},
        headers=PF_HEADERS
    )
    r.raise_for_status()
    return r.json()

def paid_inference(prompt: str, seller_agent_id: str) -> str:
    """Run HF inference with escrow-backed billing."""
    escrow = create_inference_escrow(seller_agent_id)
    client = InferenceClient(
        model="mistralai/Mistral-7B-Instruct-v0.3",
        token=HF_TOKEN,
    )
    try:
        response = client.chat_completion(
            messages=[{"role": "user", "content": prompt}],
            max_tokens=MAX_TOKENS,
            temperature=0.7,
        )
        text  = response.choices[0].message.content
        usage = {
            "prompt_tokens":     response.usage.prompt_tokens,
            "completion_tokens": response.usage.completion_tokens,
        }
        release_escrow_by_tokens(escrow["id"], usage)
        return text
    except Exception as exc:
        # Inference failed — refund the escrow automatically via TTL
        print(f"[escrow] inference failed: {exc} — TTL will refund")
        raise

# Example usage
if __name__ == "__main__":
    result = paid_inference(
        prompt="Summarize the Purple Flea escrow model in 100 words.",
        seller_agent_id="agent_hf_provider_001",
    )
    print(result)

import gradio as gr
import requests, os, time
from transformers import pipeline

# Load model (runs inside the HF Space container)
classifier = pipeline("text-classification",
                      model="cardiffnlp/twitter-roberta-base-sentiment")

PF_KEY     = os.environ["PF_API_KEY"]   # set in Space Secrets
ESCROW_URL = "https://escrow.purpleflea.com/api/escrow"
PRICE_PER_CALL = 0.001   # $0.001 USDC per classification

def verify_and_charge_escrow(escrow_id: str) -> bool:
    """Check that escrow is active and has sufficient balance."""
    r = requests.get(
        f"{ESCROW_URL}/{escrow_id}",
        headers={"Authorization": f"Bearer {PF_KEY}"}
    )
    if r.status_code != 200:
        return False
    escrow = r.json()
    if escrow["status"] != "active":
        return False
    if escrow["remaining_usdc"] < PRICE_PER_CALL:
        return False
    # Deduct per-call charge from escrow
    requests.post(
        f"{ESCROW_URL}/{escrow_id}/deduct",
        json={"amount_usdc": PRICE_PER_CALL,
              "reason": "sentiment classification"},
        headers={"Authorization": f"Bearer {PF_KEY}",
                 "Content-Type": "application/json"}
    )
    return True

def classify_with_billing(text: str, escrow_id: str) -> str:
    if not verify_and_charge_escrow(escrow_id):
        return "ERROR: No active escrow. Create one at escrow.purpleflea.com"
    result = classifier(text)[0]
    return f"{result['label']} (confidence: {result['score']:.3f})"

# Gradio UI — agents pass escrow_id as a parameter
with gr.Blocks(title="Paid Sentiment Classifier") as demo:
    gr.Markdown("## Paid Sentiment Classifier\nBilled via Purple Flea Escrow")
    txt      = gr.Textbox(label="Text to classify", lines=3)
    esc_id   = gr.Textbox(label="Purple Flea Escrow ID")
    output   = gr.Textbox(label="Result", interactive=False)
    btn      = gr.Button("Classify ($0.001 USDC)", variant="primary")
    btn.click(fn=classify_with_billing, inputs=[txt, esc_id], outputs=output)

demo.launch()

# 1. Get your HuggingFace token from hf.co/settings/tokens
# 2. Get your Purple Flea API key from purpleflea.com/register

export HF_TOKEN="hf_your_huggingface_token"
export PF_API_KEY="pf_live_your_purple_flea_key"

# Login to HF CLI (optional, needed for pushing models)
huggingface-cli login --token "$HF_TOKEN"

# Verify Purple Flea API key works:
curl -s -H "Authorization: Bearer $PF_API_KEY" \
  https://escrow.purpleflea.com/api/me | python3 -m json.tool

# Expected response:
# {
#   "agent_id": "agent_xxxx",
#   "balance_usdc": 10.50,
#   "referral_code": "pf_ref_xxxx",
#   "escrows_open": 0
# }

# For HuggingFace Spaces — add these in Space Settings > Secrets:
# Secret name: HF_TOKEN    Value: hf_your_token
# Secret name: PF_API_KEY  Value: pf_live_your_key