Il n'existe pas de package LangGraph, et vous n'en avez pas besoin. Un simple nœud dans votre appelle le vrai client , un suspend le graphe jusqu'à l'arrivée du webhook de paiement, et le handler le reprend avec les propres + de LangGraph. Les paiements sont réglés sur Base.

Installez LangGraph et le SDK de base. Aucun package supplémentaire.

Node 18+ et @langchain/langgraph 0.2+ plus le véritable client @blockchain0x/node. Il n'y a pas d'adaptateur LangGraph à ajouter dans l'un ou l'autre langage - les utilisateurs de LangGraph Python installent langgraph et le client Python blockchain0x et écrivent la même recette, avec interrupt() et Command(resume=...) du côté Python.

npm install @langchain/langgraph @blockchain0x/node

export BLOCKCHAIN0X_API_KEY=sk_test_...        # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
export BLOCKCHAIN0X_WEBHOOK_SECRET=...          # for the webhook handler

BLOCKCHAIN0X_API_KEY est une clé sk_test_ testnet ou sk_live_ mainnet de votre tableau de bord ; le client la lit depuis l'environnement. BLOCKCHAIN0X_WEBHOOK_SECRET (renvoyé une fois lorsque vous créez ou faites tourner un webhook) est nécessaire dans le processus qui gère les webhooks. Si votre graphe s'exécute dans un processus et le gestionnaire dans un autre, les deux ont besoin du même point de contrôle (par exemple, Postgres partagé) afin que le gestionnaire puisse trouver le fil suspendu.

Vérifiez le webhook, puis reprenez le fil.

Le gestionnaire vérifie la signature avec webhooks.verify du SDK Node, recherche le fil LangGraph suspendu dans votre propre mappage, définit settled avec graph.updateState, et appelle graph.invoke(null, config) pour continuer à partir de l'interruption. Pas d'aide spéciale - ce sont les propres API de LangGraph.

import express from "express";
import { webhooks } from "@blockchain0x/node";
import { graph } from "./graph";

const app = express();
// Capture the RAW body. The HMAC is over the exact bytes on the wire.
app.use(express.raw({ type: "application/json" }));

app.post("/webhooks/payment", async (req, res) => {
  const result = webhooks.verify({
    headers: req.headers,
    rawBody: req.body, // Buffer, raw bytes
    secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!,
  });
  if (!result.ok) return res.status(400).json({ code: result.code });

  if (result.eventType === "payment.sent") {
    // You map the event to the suspended graph thread (your own store).
    const config = { configurable: { thread_id: threadFor(result.eventId) } };
    await graph.updateState(config, { settled: true });
    await graph.invoke(null, config); // resume from the interrupt
  }
  res.status(200).send("ok");
});

webhooks.verify effectue HMAC-SHA256 en temps constant sur le corps brut et renvoie une union discriminée - branchez sur result.ok, pas de try/catch. Mappez result.eventId au thread que vous avez suspendu, puis graph.updateState + graph.invoke(null, config) reprend à partir du point de contrôle persistant et le graphique exécute les livraisons. Les événements expédiés sont payment.received, payment.sent, wallet.deployed et webhook.test.

Cinq pièges spécifiques à LangGraph à éviter.

Le modèle d'exécution durable de LangGraph est puissant mais a ses propres pièges autour des points de contrôle, des interruptions et des mises à jour d'état.