Record a LangChain or LangGraph agent

npm install @sanning/anchor @sanning/anchor-langchain \
  @langchain/core @langchain/langgraph zod @aws-sdk/client-s3

pip install "sanning-anchor[langchain,s3]" langgraph

import { AIMessage } from "@langchain/core/messages";
import { tool } from "@langchain/core/tools";
import {
  Command,
  END,
  interrupt,
  MemorySaver,
  MessagesAnnotation,
  START,
  StateGraph,
} from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { z } from "zod";

const recordConclusion = tool(async ({ verdict }) => verdict, {
  name: "record_conclusion",
  description: "State the verdict for the claim.",
  schema: z.object({ verdict: z.enum(["approved", "declined"]) }),
});

from langchain_core.messages import AIMessage
from langchain_core.tools import tool
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.types import Command, interrupt


@tool
def record_conclusion(verdict: str) -> str:
    """State the verdict for the claim."""
    return verdict

const graph = new StateGraph(MessagesAnnotation)
  .addNode("assess", () => ({
    messages: [
      new AIMessage({
        content: "",
        tool_calls: [
          {
            id: "call_1",
            name: "record_conclusion",
            args: { verdict: "declined" },
          },
        ],
      }),
    ],
  }))
  .addNode("tools", new ToolNode([recordConclusion]))
  .addNode("review", () => {
    const answer = interrupt({ question: "Confirm the declined verdict?" });
    return {
      messages: [
        new AIMessage(`Reviewer answered: ${JSON.stringify(answer)}`),
      ],
    };
  })
  .addEdge(START, "assess")
  .addEdge("assess", "tools")
  .addEdge("tools", "review")
  .addEdge("review", END)
  .compile({ checkpointer: new MemorySaver() });

def assess(state):
    call = {
        "id": "call_1",
        "name": "record_conclusion",
        "args": {"verdict": "declined"},
    }
    return {"messages": [AIMessage(content="", tool_calls=[call])]}


def review(state):
    answer = interrupt({"question": "Confirm the declined verdict?"})
    return {"messages": [AIMessage(content=f"Reviewer answered: {answer}")]}


graph = (
    StateGraph(MessagesState)
    .add_node("assess", assess)
    .add_node("tools", ToolNode([record_conclusion]))
    .add_node("review", review)
    .add_edge(START, "assess")
    .add_edge("assess", "tools")
    .add_edge("tools", "review")
    .add_edge("review", END)
    .compile(checkpointer=MemorySaver())
)

import {
  createAnchorer,
  LocalEd25519Signer,
  MemoryStore,
  ObjectLogStore,
} from "@sanning/anchor";
import { S3ObjectStore } from "@sanning/anchor/s3";
import { anchorCallbacks } from "@sanning/anchor-langchain";

const logStore = new ObjectLogStore(
  new S3ObjectStore({
    bucket: process.env.SANNING_LOG_BUCKET!,
    region: process.env.AWS_REGION!,
  }),
);

const anchorer = createAnchorer({
  signer: LocalEd25519Signer.fromSeedHex(process.env.SANNING_SIGNING_SEED!),
  subject: { type: "agent", agent_id: "claims-triage" },
  apiKey: process.env.SANNING_API_KEY!,
  logStore,
  store: new MemoryStore(),
});

const caseId = "case-4b19de";
const evidence = anchorCallbacks(anchorer, { caseId });

import os

from sanning_anchor import (
    Anchorer,
    AnchorCallbackHandler,
    LocalEd25519Signer,
    MemoryStore,
    ObjectLogStore,
)
from sanning_anchor.s3 import S3ObjectStore

log_store = ObjectLogStore(
    S3ObjectStore(
        bucket=os.environ["SANNING_LOG_BUCKET"],
        region=os.environ["AWS_REGION"],
    )
)

anchorer = Anchorer(
    signer=LocalEd25519Signer.from_seed_hex(os.environ["SANNING_SIGNING_SEED"]),
    subject={"type": "agent", "agent_id": "claims-triage"},
    api_key=os.environ["SANNING_API_KEY"],
    log_store=log_store,
    store=MemoryStore(),
)

case_id = "case-4b19de"
handler = AnchorCallbackHandler(anchorer, case_id=case_id)

const evidence = anchorCallbacks(anchorer, {
  caseId,
  decisions: [{ tool: recordConclusion, name: "claim_verdict" }],
});

from sanning_anchor import DecisionTool

handler = AnchorCallbackHandler(
    anchorer,
    case_id=case_id,
    decisions=[DecisionTool(record_conclusion, "claim_verdict")],
)

const evidence = anchorCallbacks(anchorer, {
  caseId,
  decisions: [{ tool: recordConclusion, name: "claim_verdict" }],
  approvals: {
    actor: "human",
    // The value that resumes the run is the answer.
    verdict: (resume) =>
      (resume as { approved?: boolean }).approved ? "approved" : "rejected",
  },
});

from sanning_anchor import ApprovalOptions

handler = AnchorCallbackHandler(
    anchorer,
    case_id=case_id,
    decisions=[DecisionTool(record_conclusion, "claim_verdict")],
    approvals=ApprovalOptions(
        actor="human",
        # The value that resumes the run is the answer.
        verdict=lambda resume: (
            "approved" if resume.get("approved") else "rejected"
        ),
    ),
)

import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";

const config = {
  configurable: { thread_id: "claim-4471" },
  callbacks: [evidence],
};

try {
  // The first call pauses at the review node. The second is the answer.
  await graph.invoke({ messages: [] }, config);
  await graph.invoke(new Command({ resume: { approved: true } }), config);
} catch (error) {
  await awaitAllCallbacks();
  await evidence.close({ outcome: "failed", reason: "error" });
  throw error;
}

config = {"configurable": {"thread_id": "claim-4471"}, "callbacks": [handler]}

try:
    # The first call pauses at the review node. The second is the answer.
    graph.invoke({"messages": []}, config)
    graph.invoke(Command(resume={"approved": True}), config)
except BaseException:
    handler.close(raise_on_gaps=False, outcome="failed", reason="error")
    raise

// LangChain.js can run callbacks in the background. Wait for them, or the
// closing record is written without the last step.
await awaitAllCallbacks();
await evidence.close({ outcome: "completed" });
if (!evidence.isComplete) {
  console.error(
    "Records are missing from the trail:",
    evidence.gaps,
    evidence.unbuilt,
  );
  process.exitCode = 1;
}

// The handler never closes the anchorer. Close it when the process is done.
await anchorer.close({ raiseOnGaps: false });
if (evidence.isComplete) {
  console.log(`Recorded case ${caseId}.`);
}

# Raises IncompleteTrailError if any record is missing from the trail.
handler.close(outcome="completed")

# The handler never closes the anchorer. Close it when the process is done.
anchorer.close()
print(f"Recorded case {case_id}.")

npx tsx agent.mts

python agent.py