Coming from LangGraph

import { z } from "zod";
import {
  Command,
  END,
  MemorySaver,
  START,
  StateGraph,
  StateSchema,
  interrupt,
  type ConditionalEdgeRouter,
  type GraphNode,
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

// Model IDs here are illustrative; substitute your provider's current models.
const model = new ChatOpenAI({ model: "gpt-4.1-mini" });

const State = new StateSchema({
  request: z.string(),
  draft: z.string().default(""),
  feedback: z.string().default(""),
  revisions: z.number().default(0),
});

const draft: GraphNode<typeof State> = async (state) => {
  const res = await model.invoke([
    { role: "system", content: "Draft a short, professional email." },
    {
      role: "user",
      content: state.feedback
        ? `${state.request}\n\nRevise this draft:\n${state.draft}\n\nFeedback: ${state.feedback}`
        : state.request,
    },
  ]);
  return { draft: res.text, revisions: state.revisions + 1 };
};

// The pause. Requires a checkpointer at compile time, and the whole node
// re-runs from the top when the graph resumes.
const review: GraphNode<typeof State> = (state) => {
  const decision = interrupt({ draft: state.draft, action: "approve or revise" }) as
    | { type: "approve" }
    | { type: "revise"; feedback: string };

  return { feedback: decision.type === "revise" ? decision.feedback : "" };
};

const send: GraphNode<typeof State> = async (state) => {
  await mailer.send(state.draft);
  return {};
};

// The revision bound is an `if` inside a router function.
const route: ConditionalEdgeRouter<typeof State, "draft" | "send"> = (state) =>
  state.feedback && state.revisions < 3 ? "draft" : "send";

const graph = new StateGraph(State)
  .addNode("draft", draft)
  .addNode("review", review)
  .addNode("send", send)
  .addEdge(START, "draft")
  .addEdge("draft", "review")
  .addConditionalEdges("review", route, ["draft", "send"])
  .addEdge("send", END)
  .compile({ checkpointer: new MemorySaver() });

const config = { configurable: { thread_id: "email-42" } };

const first = await graph.invoke(
  { request: "Ask Dana to move Thursday's review to Friday" },
  config,
);

first.__interrupt__; // [{ id, value: { draft, action } }]

const done = await graph.invoke(new Command({ resume: { type: "approve" } }), config);

import { z } from "zod";
import { openai } from "@ai-sdk/openai";
import { getAcceptedEvents, persistSnapshot, runAgent, setupAgent } from "@statelyai/agent";
import { createAiSdkExecutors, defineModels } from "@statelyai/agent/ai-sdk";

const models = defineModels({ writer: openai("gpt-4.1-mini") });

const agentSetup = setupAgent({
  models,
  context: z.object({
    request: z.string(),
    draft: z.string().nullable(),
    feedback: z.string().nullable(),
    revisions: z.number(),
  }),
  input: z.object({ request: z.string() }),
  output: z.object({ draft: z.string() }),
  events: {
    APPROVE: {}, // `{}` is shorthand for a payload-less event
    REVISE: z.object({ feedback: z.string() }),
  },
  requests: {
    writeDraft: {
      schemas: {
        input: z.object({ request: z.string(), feedback: z.string().nullable() }),
        output: z.object({ draft: z.string() }),
      },
      model: "writer",
      system: "Draft a short, professional email.",
      prompt: ({ input }) =>
        input.feedback ? `${input.request}\n\nRevise per: ${input.feedback}` : input.request,
    },
  },
});

const machine = agentSetup.createMachine({
  context: ({ input }) => ({
    request: input.request,
    draft: null,
    feedback: null,
    revisions: 0,
  }),
  output: ({ context }) => ({ draft: context.draft ?? "" }),
  initial: "drafting",
  states: {
    drafting: {
      invoke: {
        src: "writeDraft",
        input: ({ context }) => ({ request: context.request, feedback: context.feedback }),
        onDone: ({ output }) => ({ target: "reviewing", context: { draft: output.draft } }),
      },
    },
    // No invoke, so runAgent settles { status: 'idle', snapshot } here.
    reviewing: {
      on: {
        APPROVE: { target: "sent" },
        // The revision bound is a guard. Past 3 revisions, REVISE stops being
        // an accepted event at all: no router can route around it.
        REVISE: ({ context, event }) =>
          context.revisions < 3
            ? {
                target: "drafting",
                context: { feedback: event.feedback, revisions: context.revisions + 1 },
              }
            : undefined,
      },
    },
    sent: { type: "final" },
  },
});

const executors = createAiSdkExecutors({ models });

const first = await runAgent(machine, {
  input: { request: "Ask Dana to move Thursday's review to Friday" },
  executors,
});

if (first.status === "idle") {
  getAcceptedEvents(first.snapshot); // ['APPROVE', 'REVISE'], the exact choices to render
  await store.save("email-42", JSON.stringify(persistSnapshot(first.snapshot)));
}

// ...a later request, possibly another process...
const done = await runAgent(machine, {
  snapshot: JSON.parse(await store.load("email-42")),
  event: { type: "APPROVE" },
  executors,
});

import {
  END,
  START,
  StateGraph,
  StateSchema,
  type ConditionalEdgeRouter,
  type GraphNode,
} from "@langchain/langgraph";
import { z } from "zod";

const State = new StateSchema({
  question: z.string(),
  docs: z.string(),
  grade: z.string().default(""),
  rewrites: z.number().default(0),
});

const grade: GraphNode<typeof State> = async (state) => {
  const res = await model.invoke([
    {
      role: "system",
      content: "Reply GENERATE if the documents answer the question, else REWRITE.",
    },
    { role: "user", content: `Question:\n${state.question}\n\nDocuments:\n${state.docs}` },
  ]);
  // Whatever the model said, unvalidated, is now the routing key.
  return { grade: res.text.trim() };
};

const route: ConditionalEdgeRouter<typeof State, "generate" | "rewrite"> = (state) =>
  state.grade === "REWRITE" && state.rewrites < 2 ? "rewrite" : "generate";

const graph = new StateGraph(State)
  .addNode("grade", grade)
  .addNode("generate", generate)
  .addNode("rewrite", rewrite)
  .addEdge(START, "grade")
  .addConditionalEdges("grade", route, ["generate", "rewrite"])
  .addEdge("generate", END)
  .compile();

grading: {
  invoke: {
    src: "agent.decide",
    input: ({ context }) => ({
      model: "grader",
      system: "GENERATE if the documents answer the question, else REWRITE.",
      prompt: `Question:\n${context.question}\n\nDocuments:\n${context.docs}`,
      allowedEvents: ["GENERATE", "REWRITE"],
    }),
  },
  on: {
    GENERATE: { target: "generating" },
    // Bound the correction loop: past 2 rewrites, REWRITE is illegal.
    REWRITE: ({ context }) =>
      context.rewrites < 2
        ? { target: "rewriting", context: { rewrites: context.rewrites + 1 } }
        : undefined,
  },
}