Eve

npm install eve ai samva zod

import { defineChannel, POST } from "eve/channels";

export default defineChannel<MessageRef>({
  state: { eventId: "", mailboxId: "", messageId: "", channel: "email" },
  metadata: (state) => ({ ...state }),
  routes: [
    POST("/samva/messages", async (request, { from }) => {
      const token = process.env.EVE_RELAY_TOKEN;
      if (token === undefined || token === "") {
        throw new Error("Missing required env var EVE_RELAY_TOKEN");
      }
      return await acceptMessage(request, token, (address, message, options) =>
        from(address).send(message, options),
      );
    }),
  ],
});

import { defineTool } from "eve/tools";
import { SamvaApiError } from "samva";
import { z } from "zod";

import { claimEvent, holdForReplyRetry, releaseEvent } from "../lib/claim";
import { parseMessageRef } from "../lib/message";
import { samvaFromEnv, submitReply } from "../lib/reply";

// The ids come from the channel's state, so the model supplies only the text: it cannot choose
// the recipient, channel, or thread.
export default defineTool({
  description:
    "Submit a reply to the customer's message. It is held for a person's approval before it is sent.",
  inputSchema: z.object({ text: z.string().trim().min(1).describe("The plain-text reply.") }),
  endsTurn: true,
  async execute({ text }, ctx) {
    const ref = parseMessageRef(ctx.channel.metadata);
    if (!claimEvent(ref.eventId, "reply")) return { state: "alreadyActed" };
    try {
      return await submitReply(samvaFromEnv(), ref, text);
    } catch (error) {
      // A 4xx answer means Samva refused the reply and recorded nothing, so either tool may act
      // next. Anything else (a lost response, a server error) may have recorded it: keep the
      // event for a reply retry, which the reply key makes safe.
      const refused =
        error instanceof SamvaApiError &&
        error.status !== undefined &&
        error.status >= 400 &&
        error.status < 500;
      if (refused) releaseEvent(ref.eventId);
      else holdForReplyRetry(ref.eventId);
      throw error;
    }
  },
});

import { MailboxSendConflictError, WhatsAppServiceWindowClosedError } from "samva";

const reply =
  ref.channel === "whatsapp"
    ? { id: ref.mailboxId, messageId: ref.messageId, channel: "whatsapp" as const, text }
    : { id: ref.mailboxId, messageId: ref.messageId, text };
try {
  const receipt = await samva.mailboxes.reply(reply, { idempotencyKey: `reply:${ref.eventId}` });
  return { state: receipt.state, actionId: receipt.actionId };
} catch (error) {
  if (error instanceof MailboxSendConflictError) {
    return { state: "alreadyAnswered", actionId: error.receipt.actionId };
  }
  if (error instanceof WhatsAppServiceWindowClosedError) return { state: "windowClosed" };
  throw error;
}

for await (const event of samva.mailboxes.events({ cursor, mailboxIds: [options.mailboxId] })) {
  await handleEvent(event, options.forward, log);
  await options.store.save(event.cursor);
  cursor = event.cursor;
}