XRPL SDK (Python)

from blockrun_llm_xrpl import LLMClient

client = LLMClient(
    seed="sEd...",                           # Wallet seed (or use env var)
    api_url="https://xrpl.blockrun.ai/api",  # Optional (offline — see banner)
    rpc_url="https://xrplcluster.com",       # XRPL RPC used for balance reads
    timeout=600.0                            # Request timeout in seconds
)

response = client.chat(
    "openai/gpt-5.5",
    "Explain quantum computing",
    system="You are a physics teacher.",  # Optional system prompt
    max_tokens=500,                        # Optional max output (default 1024)
    temperature=0.7                        # Optional temperature
)

messages = [
    {"role": "system", "content": "You are helpful."},
    {"role": "user", "content": "What is 2+2?"}
]

result = client.chat_completion(
    "openai/gpt-5.5",
    messages,
    max_tokens=100,
    temperature=0.7,
    top_p=0.9
)

print(result.choices[0].message.content)
print(f"Tokens used: {result.usage.total_tokens}")

balance = client.get_balance()
print(f"RLUSD Balance: {balance}")

spending = client.get_spending()
print(f"Spent ${spending['total_usd']:.4f} across {spending['calls']} calls")

print(f"Paying from: {client.address}")

from blockrun_llm_xrpl import LLMClient

client = LLMClient()

# Let ClawRouter pick the model automatically
result = client.smart_chat("What is 2+2?")

print(result.response)           # "4"
print(result.model)              # "moonshot/kimi-k2.5" (AUTO profile, SIMPLE tier)
print(result.routing.tier)       # "SIMPLE"
print(result.routing.savings)    # 0.94 (94% savings vs baseline)

# Force free models (great for development)
result = client.smart_chat(
    "Explain recursion",
    routing_profile="free"
)
print(result.model)  # "nvidia/gpt-oss-120b"

# Maximum savings mode
result = client.smart_chat(
    "Summarize this article: ...",
    routing_profile="eco"
)

# Premium mode for critical tasks
result = client.smart_chat(
    "Review this contract for legal issues...",
    routing_profile="premium"
)
print(result.model)  # "anthropic/claude-opus-4.5"

result = client.smart_chat("Prove that sqrt(2) is irrational")

# Access full routing decision
routing = result.routing
print(f"Model: {routing.model}")           # "xai/grok-4-1-fast-reasoning"
print(f"Tier: {routing.tier}")             # "REASONING"
print(f"Confidence: {routing.confidence}") # 0.97
print(f"Method: {routing.method}")         # "rules"
print(f"Reasoning: {routing.reasoning}")   # "Detected: math proof..."
print(f"Estimated cost: ${routing.cost_estimate:.4f}")
print(f"Baseline cost: ${routing.baseline_cost:.4f}")
print(f"Savings: {routing.savings:.0%}")   # "97%"

import asyncio
from blockrun_llm_xrpl import AsyncLLMClient

async def main():
    async with AsyncLLMClient() as client:
        result = await client.smart_chat(
            "What's the weather like?",
            routing_profile="eco"
        )
        print(result.response)

asyncio.run(main())

from blockrun_llm_xrpl import create_wallet

address, seed = create_wallet()
print(f"Address: {address}")
print(f"Seed: {seed}")  # Save this securely!

# .env (add to .gitignore!)
BLOCKRUN_XRPL_SEED=sEd...your_seed_here

# app.py
import os
from blockrun_llm_xrpl import LLMClient
from dotenv import load_dotenv

load_dotenv()

if not os.getenv("BLOCKRUN_XRPL_SEED"):
    raise ValueError("BLOCKRUN_XRPL_SEED not set")

client = LLMClient()  # Reads from environment

from blockrun_llm_xrpl import get_xrp_balance, get_rlusd_balance, get_balances

print(get_xrp_balance(client.address))
print(get_rlusd_balance(client.address))
print(get_balances(client.address))   # {"xrp": ..., "rlusd": ...}

import asyncio
from blockrun_llm_xrpl import AsyncLLMClient

async def main():
    async with AsyncLLMClient() as client:
        # Single request
        response = await client.chat("openai/gpt-5.5", "Hello!")

        # Concurrent requests
        tasks = [
            client.chat("openai/gpt-5.5", "What is 2+2?"),
            client.chat("anthropic/claude-sonnet-4.6", "What is 3+3?"),
        ]
        responses = await asyncio.gather(*tasks)

asyncio.run(main())

from blockrun_llm_xrpl import LLMClient, APIError, PaymentError

client = LLMClient()

try:
    response = client.chat("openai/gpt-5.5", "Hello!")
except PaymentError as e:
    print(f"Payment failed: {e}")
    # Check your RLUSD balance
except APIError as e:
    print(f"API error ({e.status_code}): {e}")
    print(f"Details: {e.response}")

class ChatResponse:
    id: str
    object: str
    created: int
    model: str
    choices: List[ChatChoice]
    usage: Optional[ChatUsage]

class ChatChoice:
    index: int
    message: ChatMessage
    finish_reason: Optional[str]

class ChatMessage:
    role: Literal["system", "user", "assistant"]
    content: str

class ChatUsage:
    prompt_tokens: int
    completion_tokens: int
    total_tokens: int

from blockrun_llm_xrpl import (
    RoutingDecision,   # model, tier, confidence, method, reasoning, cost_estimate, baseline_cost, savings
    SmartChatResponse, # response, model, routing
)