LangGraph

npm install samva langchain @langchain/core @langchain/anthropic zod

import { tool } from "@langchain/core/tools";
import { MailboxSendConflictError, WhatsAppServiceWindowClosedError } from "samva";
import { z } from "zod";

let outcome: Outcome = { kind: "none" };
// Set before any await: a model can call both tools in one turn, and the calls run together.
let claimed = false;

const reply_to_customer = tool(
  async ({ text }) => {
    if (claimed) return "You already finished this message. Do not call again.";
    claimed = true;
    // Without channel: "whatsapp", Samva treats the reply as email and rejects a WhatsApp thread.
    const reply =
      received.channel === "whatsapp"
        ? {
            id: received.mailboxId,
            messageId: received.messageId,
            channel: "whatsapp" as const,
            text,
          }
        : { id: received.mailboxId, messageId: received.messageId, text };
    try {
      const receipt = await samva.mailboxes.reply(reply, { idempotencyKey: `reply:${eventId}` });
      outcome = { kind: "replied" };
      return `Submitted. The reply is ${receipt.state}.`;
    } catch (error) {
      if (error instanceof MailboxSendConflictError) {
        outcome = { kind: "replied" };
        log(
          `already answered ${received.messageId}: ${error.receipt.state}, action ${error.receipt.actionId}`,
        );
        return "This message was already answered. Do not call again.";
      }
      if (error instanceof WhatsAppServiceWindowClosedError) {
        outcome = { kind: "left" };
        log(`skipped ${received.messageId}: WhatsApp service window closed`);
        return "The WhatsApp window is closed, so nothing was sent. Do not call again.";
      }
      outcome = { kind: "failed", error };
      return "Sending failed. Do not call again.";
    }
  },
  {
    name: "reply_to_customer",
    description:
      "Reply to the customer's message with plain text. The reply is held for a person's approval.",
    schema: z.object({ text: z.string().trim().min(1).describe("The reply text to send.") }),
    // Both tools finish the message: end the run instead of calling the model again.
    returnDirect: true,
  },
);

const leave_for_person = tool(
  async ({ reason }) => {
    if (claimed) return "You already finished this message. Do not call again.";
    claimed = true;
    outcome = { kind: "left" };
    log(`left ${received.messageId} for a person: ${reason}`);
    return "Left for a person. Nothing was sent.";
  },
  {
    name: "leave_for_person",
    description:
      "Send nothing and leave the message for a person. Use when the instructions do not cover it.",
    schema: z.object({ reason: z.string().describe("One short sentence on why.") }),
    returnDirect: true,
  },
);

import { ChatAnthropic } from "@langchain/anthropic";
import { createAgent } from "langchain";

const model = new ChatAnthropic({ model: "claude-opus-5-5" });

for await (const event of samva.mailboxes.events({ mailboxIds: [mailboxId] })) {
  if (event.type !== "mailbox.message.received") continue;
  const received = parseReceivedMessage(event.data);
  if (received === undefined) continue;

  const { tools, outcome } = messageTools(samva, received, event.id, console.log);
  const agent = createAgent({ model, tools, systemPrompt: systemPrompt(instructions) });
  await agent.invoke(
    { messages: [{ role: "user", content: userTurn(received) }] },
    { recursionLimit: 8 },
  );

  // A refused reply stops the event, so the loop does not save a cursor past it.
  const result = outcome();
  if (result.kind === "failed") throw result.error;
}