Intégration de paiement CrewAI.
Donnez à une équipe CrewAI un portefeuille. Un agent trésorier dédié envoie des USDC, règle les factures et lit les soldes pendant que les agents de travail restent concentrés sur le travail.
Blockchain0x fournit un vrai package Python, . Installez-le, définissez , appelez , et transmettez les outils à un agent trésorier dédié. Cet agent peut envoyer des USDC, régler une facture avec une preuve on-chain et lire les portefeuilles, tandis que les agents de travail de l'équipe n'ont aucun accès au portefeuille. USDC se règle sur Base.
La force de CrewAI est la séparation des rôles. Utilisez-le aussi pour le portefeuille.
D'autres frameworks empilent chaque outil sur un seul agent. La conception de CrewAI encourage la séparation des rôles : un chercheur recherche, un écrivain écrit, un réviseur révise. L'argent mérite le même traitement - un agent trésorier dédié détient les outils de portefeuille, et les agents de travail n'en détiennent aucun. L'autorité de dépense vit à un seul endroit au lieu de fuir à travers chaque agent qui se trouve dans l'équipage.
Cette structure rend également les pistes d'audit plus claires. Lorsque l'USDC se déplace, vous savez exactement quel agent l'a déplacé (le trésorier) et pour quelle tâche c'était (celle qui lui a été transférée). Les intégrations à agent unique brouillent cette ligne et rendent l'analyse des dépenses par tâche plus difficile.
Une installation pip. Une variable d'environnement.
Le paquet nécessite Python 3.10 ou une version plus récente et fonctionne avec poetry ou pip. Il intègre le SDK blockchain0x de base et crewai comme dépendances ; rien d'autre à ajouter.
pip install blockchain0x-crewaiexport BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY est une clé sk_test_ testnet ou sk_live_ mainnet de votre tableau de bord Blockchain0x, et c'est la seule variable dont l'adaptateur a besoin - il transmet la clé au backend et ne conserve aucun secret. Pour le gestionnaire de webhook ci-dessous, vous devez également définir BLOCKCHAIN0X_WEBHOOK_SECRET, que le tableau de bord renvoie une fois lorsque vous créez ou faites tourner un webhook.
Une équipe de deux agents fonctionnelle avec des rôles de facturation et de recherche.
Voici une équipe CrewAI complète où un agent trésorier paie un fournisseur de données en USDC, et un agent chercheur utilise le résultat. Le trésorier détient les outils de portefeuille ; le chercheur n'en détient aucun. C'est le modèle canonique pour une équipe qui dépense.
from crewai import Agent, Task, Crew from blockchain0x import Client from blockchain0x_crewai import create_blockchain0x_toolset client = Client() # reads BLOCKCHAIN0X_API_KEY from the environment tools = create_blockchain0x_toolset(client) # A dedicated treasurer holds the wallet tools; the work agents do not. treasurer = Agent( role="Treasurer", goal="Pay vendor invoices in USDC within owner-set limits", backstory="Operates a Blockchain0x agent wallet on Base.", tools=tools, allow_delegation=False, ) researcher = Agent( role="Senior Market Analyst", goal="Produce a thorough Q4 LLM market analysis", backstory="A specialist analyst with 10 years in tech-market research.", tools=[], allow_delegation=False, ) pay_task = Task( description="Pay 0.01 USDC from our agent wallet to the data vendor at 0xVendor.", expected_output="The transaction hash of the settled payment.", agent=treasurer, ) research_task = Task( description="Using the purchased dataset, write the Q4 LLM market analysis.", expected_output="A 1,500-word market analysis.", agent=researcher, context=[pay_task], ) crew = Crew(agents=[treasurer, researcher], tasks=[pay_task, research_task]) result = crew.kickoff()
When you call crew.kickoff(), the pay_task runs first: the treasurer calls blockchain0x_send_payment, the SDK submits the transfer on Base, and the transaction hash is the task output. The research_task runs next and uses the purchased result. amount_wei is USDC base units, so 0.01 USDC is the string "10000". On a sk_test_ key the whole flow runs on Base Sepolia, and payments.create can answer 503 until the chain adapter is wired for your network.
Déclenchement de l'équipe suivante lorsqu'un paiement arrive.
Lorsque l'USDC est réglé à votre agent, Blockchain0x envoie un événement signé à votre URL de webhook. L'outil de vérification est inclus dans le SDK Node ; un service Python vérifie manuellement contre le HMAC documenté, qui est tout ce que fait l'outil. Exemple Flask ci-dessous ; le même code fonctionne dans FastAPI ou tout autre framework web Python.
import hmac, hashlib, os, time from flask import Flask, request, abort app = Flask(__name__) SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") def receive(): raw = request.get_data() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") # Header is "t=<unix>,v1=<hex>"; some proxies send bare hex + the ts header. 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: abort(401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": run_followup_for(request.get_json()) # USDC landed - do the work return "ok", 200
Voici le véritable algorithme : HMAC-SHA256 sur la chaîne t.rawBody, une comparaison en temps constant, et une fenêtre de répétition de 300 secondes. Lisez le corps brut (request.get_data()), jamais request.get_json() re-sérialisé, car cela change les octets que la signature couvre. Architecture : faites en sorte que le gestionnaire mette en file d'attente un travail (Celery, RQ, une liste Redis) qui déclenche l'exécution réelle de CrewAI. Appeler crew.kickoff() à l'intérieur du gestionnaire peut prendre des minutes et faire expirer la requête HTTP.
Remettez à l'équipe l'ensemble des outils, ou juste un outil.
create_blockchain0x_toolset retourne les cinq outils : blockchain0x_send_payment, blockchain0x_settle_invoice, blockchain0x_get_wallet, blockchain0x_list_wallets, et blockchain0x_get_transaction. Si une équipe n'a besoin que de payer, donnez-lui juste celui-là avec une seule usine.
from blockchain0x_crewai import create_payment_tool pay = create_payment_tool(client) # amount_wei is USDC base units: 6 decimals, so 10000 = 0.01 USDC. pay.run(agent_id="agt_123", to="0xRecipient", amount_wei="10000")
Les usines par capacité sont create_payment_tool, create_invoice_tool, create_wallet_tool, create_wallets_list_tool et create_transaction_tool. Les exemples de source et de testnet se trouvent dans le dépôt SDK Python; la matrice de support CrewAI se trouve dans la documentation.
Cinq choses à surveiller lors de l'intégration de la facturation dans une équipe.
La conception basée sur les rôles de CrewAI est ce qui rend l'intégration des paiements plus propre que d'autres frameworks. Elle a aussi ses propres pièges. Connaître cela à l'avance fait gagner du temps.
Mettre les outils de portefeuille sur le mauvais agent
Les agents CrewAI ont des rôles. Remettez les outils de portefeuille au chercheur, qui devrait être en train de faire des recherches, et le LLM commence à essayer de déplacer de l'argent en pleine analyse. Le modèle propre est un agent trésorier dédié qui détient les outils et fonctionne comme sa propre tâche ; les agents de travail n'ont aucun accès au portefeuille. L'exemple ci-dessus suit cette forme. Copiez-le.
Processus séquentiels vs hiérarchiques
CrewAI prend en charge l'exécution séquentielle (par défaut) et hiérarchique. Avec la hiérarchique, un agent manager orchestre l'équipage. Si le manager est autorisé à déléguer les outils de portefeuille, il peut les remettre à n'importe quel subordonné, ce qui est exactement ce que vous ne voulez pas pour l'autorité de dépense. Soit gardez les outils sur un agent dédié et exécutez séquentiellement, soit restreignez les règles de délégation du manager.
Lecture de l'état de règlement à partir du contexte de la tâche
Le règlement entrant est asynchrone. Si la tâche de recherche liste la tâche de paiement dans son contexte (bien) mais que le LLM essaie ensuite de lire un statut de paiement final à partir de ce contexte (pas bien, la confirmation arrive plus tard par webhook), vous obtenez une sortie confuse. Gardez le travail en aval sur un signal déclenché par le webhook, pas sur le contexte de la tâche. Les rappels de tâche de CrewAI sont le bon crochet.
Les montants sont des unités de base USDC, sous forme de chaînes
blockchain0x_send_payment takes amount_wei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000". CrewAI passes tool inputs through as-is, so a Python float arrives as a float and the SDK rejects it - but the error reads like a CrewAI tool error, which throws off first integrators. Pass a string.
Gestionnaire de webhook en dehors du processus d'équipage
Votre gestionnaire de webhook est généralement un processus Flask ou FastAPI séparé, pas partie de l'exécution de l'équipe. L'équipe termine son kickoff() et retourne ; le webhook arrive plus tard lorsque le paiement est réglé. Reliez les deux avec une file d'attente ou une ligne de base de données que le webhook écrit et que l'équipe lit lors de sa prochaine exécution. Ne gardez pas une équipe en vie en attendant un webhook - les exécutions CrewAI sont conçues pour être de courte durée.