Integrazione OpenAI Agents SDK.
Non esiste un pacchetto Agents SDK, e non ne hai bisogno. Decora una funzione con @function_tool, chiama il vero client blockchain0x, e il tuo agente può muovere USDC su Base.
Non esiste un package specifico per OpenAI Agents SDK, e non ne hai bisogno. L'SDK trasforma una funzione decorata in uno strumento con , quindi avvolgi il vero client Python in una funzione e lo aggiungi al tuo . L'agente può inviare USDC, saldare fatture e leggere i wallet - su singoli agenti, handoff e sulla sottostante Responses API. I pagamenti si regolano su Base.
La superficie di chiamata agli strumenti più pulita che OpenAI fornisce.
L'OpenAI Agents SDK (rilasciato nel 2025) è il modo raccomandato da OpenAI per costruire agenti sopra l'API delle Risposte. Astrarre il boilerplate attorno alla registrazione degli strumenti, ai loop di messaggi e ai passaggi tra agenti, e produce codice Python pulito e tipizzato. Se stai iniziando un progetto di agente incentrato su OpenAI oggi e non hai preferenze di framework, questo è l'SDK che raccomandiamo.
La ricetta è intenzionalmente sottile. send_usdc è una funzione semplice decorata con @function_tool; la aggiungi all'elenco degli strumenti di un Agente e il Runner la raccoglie. Nessuna configurazione speciale, nessun wrapper extra, nessun fork dell'SDK. Quando l'SDK degli Agenti rilascia una nuova funzionalità (input multi-modali, agenti vocali), la tua funzione continua a funzionare perché si basa sulla superficie standard di chiamata degli strumenti - nulla di specifico per la versione vive in essa.
Installa l'Agents SDK e il core SDK. Due chiavi.
Non esiste un pacchetto blockchain0x Agents SDK da aggiungere. Installa l'OpenAI Agents SDK (il pacchetto openai-agents, Python 3.10+) e il vero core SDK blockchain0x, quindi scrivi la funzione qui sotto. Questa è l'intera lista delle dipendenze.
pip install openai-agents blockchain0xexport OPENAI_API_KEY=sk-... export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
OPENAI_API_KEY è la tua chiave OpenAI esistente (l'Agents SDK la usa per la Responses API sottostante). BLOCKCHAIN0X_API_KEY è una chiave sk_test_ per testnet o sk_live_ per mainnet dalla tua dashboard; il client la legge dall'ambiente. Se il tuo agent riceve anche denaro, l'handler del webhook richiede inoltre BLOCKCHAIN0X_WEBHOOK_SECRET.
Un @function_tool che paga, consegnato a un Agente.
Di seguito è l'intera integrazione. send_usdc chiama il reale client blockchain0x; @function_tool lo trasforma in uno strumento e il Runner orchestra la chiamata. L'SDK legge gli suggerimenti di tipo e la docstring per costruire lo schema, quindi mantienili onesti. Eseguilo e l'agente sposta USDC su Base.
from agents import Agent, Runner, function_tool from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment @function_tool def send_usdc(agent_id: str, to: str, amount_wei: str) -> str: """Send a USDC payment from an agent wallet. amount_wei is USDC base units (6 decimals), so "10000" is 0.01 USDC. """ return str( blockchain0x.payments.create(body={"agentId": agent_id, "to": to, "amountWei": amount_wei}) ) agent = Agent( name="treasurer", instructions="You pay vendor invoices in USDC within owner-set limits.", tools=[send_usdc], model="gpt-4o", ) result = await Runner.run( agent, input="Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset.", ) print(result.final_output)
When the agent decides to pay, it calls send_usdc, the SDK submits the transfer, and you get a transaction hash back. amount_wei is base units, so 0.01 USDC is "10000". A sk_test_ key keeps it on Base Sepolia until you switch to sk_live_. Add more functions - read a wallet, settle an invoice - the same way; each is another @function_tool in the list.
Conferma i pagamenti in entrata con un webhook firmato.
Se il tuo agente riceve anche USDC, confermalo con il webhook piuttosto che tramite polling. L'helper di verifica è incluso nel Node SDK; in un servizio Python verifichi manualmente contro l'HMAC documentato, che è tutto ciò che fa l'helper. Esempio FastAPI qui sotto; lo stesso codice funziona in qualsiasi framework Python asincrono.
import hmac, hashlib, os, time from fastapi import FastAPI, Request, HTTPException app = FastAPI() SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") async def receive(request: Request): raw = await request.body() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p) t, v1 = parts.get("t", ts), parts.get("v1", sig) want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest() if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300: raise HTTPException(status_code=401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": await trigger_followup() # USDC landed - run the next step return {"ok": True}
L'algoritmo è HMAC-SHA256 sulla stringa t.rawBody, un confronto a tempo costante e una finestra di replay di 300 secondi. Leggi il corpo grezzo tramite await request.body(), mai request.json() rieseguito, perché ciò cambia i byte coperti dalla firma. Gli eventi spediti sono payment.received, payment.sent, wallet.deployed e webhook.test. Per lavori di follow-up pesanti, accoda un lavoro (Celery, arq) e rispondi 200 immediatamente anziché bloccare il gestore.
Il client che stai avvolgendo è aperto. Leggilo.
Non esiste un starter package Agents SDK da clonare - la ricetta sopra è l'integrazione. Gli SDK blockchain0x sono open source su GitHub; questa ricetta incapsula il Python SDK (blockchain0x-python), con la superficie completa dei metodi nella documentazione. Consultala come riferimento per i body delle funzioni.
github.com/tosh-labs/blockchain0x-pythonLa superficie completa dei metodi dell'SDK e gli scope sono documentati in the docs. Inizia con una chiave sk_test_ su Base Sepolia, poi passa a sk_live_ quando la funzione si comporta come previsto.
Cinque cose da tenere d'occhio alla prima integrazione.
Questi provengono dalla nostra casella di supporto. Conoscerli in anticipo risparmia un'ora ciascuno.
Non esiste un pacchetto Agents SDK - avvolgi l'SDK
Blockchain0x fornisce adattatori per LangChain e CrewAI oltre al server MCP; non esiste un pacchetto OpenAI Agents SDK dedicato. La ricetta sopra è il percorso: decora una funzione tipizzata semplice con @function_tool, chiama il reale client blockchain0x all'interno e aggiungilo a Agent(tools=[...]). L'SDK legge la firma e la docstring per costruire lo schema dello strumento, quindi mantieni la docstring accurata.
Agents SDK non è l'Assistants API
L'SDK degli OpenAI Agents (il pacchetto openai-agents, importato come agents) è un prodotto diverso dall'API Assistants più vecchia. La ricetta si rivolge all'SDK degli Agents: Agente + Runner + @function_tool sull'API delle Risposte. Se stai chiamando client.beta.assistants.create(...), sei sul modello più vecchio di thread/runs che OpenAI sta dismettendo - passa all'SDK degli Agents e la funzione sopra si integra direttamente.
Gli importi sono unità base USDC, come stringhe
payments.create takes amountWei: a string of USDC base units, not a float. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the function argument as str; a float will lose precision before it reaches the API. Keep it a string end to end.
send_payment può rispondere 503 all'inizio
payments.create non ripete per impostazione predefinita e può restituire 503 fino a quando l'adattatore della catena non è collegato alla tua rete. Cattura l'errore all'interno della tua funzione e restituisci un messaggio chiaro su cui il modello può agire, piuttosto che lasciare che il Runner continui a girare. La chiave di idempotenza auto-mintata significa che un tentativo manuale non comporterà un pagamento doppio.
Runtime solo asincrono
L'SDK degli agenti è prima di tutto asincrono - attendi Runner.run(...). La chiamata blockchain0x all'interno del tuo strumento è sincrona, il che va bene per un singolo pagamento veloce ma blocca il ciclo sotto carico. Se stai eseguendo molti agenti concorrenti, incapsula la chiamata SDK con asyncio.to_thread. Da un punto di ingresso sincrono, usa asyncio.run() a livello superiore.