Customer Support AI Agent

npx eve@latest init support-agent --model anthropic/claude-sonnet-5
cd support-agent
npm install agentmail svix
export AGENTMAIL_API_KEY="..."

import { AgentMailClient } from "agentmail";

export const agentmail = new AgentMailClient(); // reads AGENTMAIL_API_KEY
export const INBOX = process.env.SUPPORT_INBOX!;      // e.g. [email protected]
export const OPERATOR = process.env.OPERATOR_EMAIL!;  // operator address, e.g. [email protected]

import { DatabaseSync } from "node:sqlite";

const db = new DatabaseSync("support.db");
db.exec("CREATE TABLE IF NOT EXISTS processed (message_id TEXT PRIMARY KEY)");

export function claim(messageId: string): boolean {
  try {
    db.prepare("INSERT INTO processed VALUES (?)").run(messageId);
    return true;
  } catch {
    return false; // already processed: webhook deliveries repeat
  }
}

const inbox = await agentmail.inboxes.create({
  username: "support",
  domain: "help.example.com",
  displayName: "Acme Support",
});

await agentmail.inboxes.lists.create(INBOX, "receive", "block", { entry: "spammy.example" });

import { defineTool } from "eve/tools";
import { z } from "zod";
import { readdir, readFile } from "node:fs/promises";

export default defineTool({
  description:
    "Search the help-center docs. Returns the most relevant passages. " +
    "Only answers backed by a returned passage may go to a customer.",
  inputSchema: z.object({ query: z.string() }),
  async execute({ query }) {
    const words = query.toLowerCase().split(/\s+/);
    const results = [];
    for (const file of await readdir("./docs")) {
      const text = await readFile(`./docs/${file}`, "utf8");
      const score = words.filter((w) => text.toLowerCase().includes(w)).length;
      if (score > 0) results.push({ file, score, text: text.slice(0, 3000) });
    }
    return results.sort((a, b) => b.score - a.score).slice(0, 3);
  },
});

import { defineTool } from "eve/tools";
import { z } from "zod";
import { agentmail, INBOX } from "../lib/agentmail";

export default defineTool({
  description: "Search past support conversations for how a question was answered before.",
  inputSchema: z.object({ query: z.string() }),
  async execute({ query }) {
    const results = await agentmail.inboxes.threads.search(INBOX, { q: query });
    return results.threads.map((t) => ({
      threadId: t.threadId,
      subject: t.subject,
      preview: t.preview,
    }));
  },
});

const webhook = await agentmail.webhooks.create({
  url: "https://support-agent.example.com/webhooks/agentmail",
  eventTypes: ["message.received"],
  inboxIds: [INBOX],
  clientId: "support-agent-v1",
});
// Save webhook.secret as AGENTMAIL_WEBHOOK_SECRET. It is shown once.

import { defineChannel, POST } from "eve/channels";
import { Webhook } from "svix";
import { claim } from "../lib/store";

const verifier = new Webhook(process.env.AGENTMAIL_WEBHOOK_SECRET!);

export default defineChannel({
  turnPolicy: "queue",
  routes: [
    POST("/webhooks/agentmail", async (request, { from }) => {
      const payload = await request.text();
      // svix 2.x: verify() only checks the signature; parse the payload yourself
      try {
        verifier.verify(payload, {
          "svix-id": request.headers.get("svix-id") ?? "",
          "svix-timestamp": request.headers.get("svix-timestamp") ?? "",
          "svix-signature": request.headers.get("svix-signature") ?? "",
        });
      } catch {
        return new Response(null, { status: 400 });
      }
      const event = JSON.parse(payload);

      const message = event.message;
      if (!claim(message.message_id)) return new Response(null, { status: 200 });

      await from(message.thread_id).send(
        `New support message from ${message.from} in thread ${message.thread_id}. ` +
          `Handle it per the playbook.`,
        { auth: null },
      );
      return new Response(null, { status: 200 });
    }),
  ],
});

You are Acme's support agent. When a message arrives: fetch it and read its
extracted_text (what the customer wrote, without quoted history). Then
search_docs and search_past_threads for the answer.

If a returned passage or past thread clearly answers the question: reply
in-thread with reply_to_customer. Keep it short, answer first, then link the
doc you used. Do not say more than the sources support.

Escalate instead of replying when any of these is true: the sources do not
clearly answer it, the customer is upset, or the request involves billing,
refunds, or account changes.

Never reply to a message with an Auto-Submitted header. Never reply in a
thread labeled needs-human-review. Never send more than two replies in one
thread without a human involved.

import { defineTool } from "eve/tools";
import { z } from "zod";
import { agentmail, INBOX } from "../lib/agentmail";

export default defineTool({
  description: "Reply to the customer in their thread.",
  inputSchema: z.object({ messageId: z.string(), text: z.string() }),
  async execute({ messageId, text }) {
    const reply = await agentmail.inboxes.messages.reply(
      INBOX,
      messageId,
      { text },
      // message ids are RFC Message-IDs (<...@...>); the header allows only A-Z a-z 0-9 - . _ ~
      { headers: { "Idempotency-Key": `reply-${messageId}`.replace(/[^A-Za-z0-9._~-]/g, "_") } },
    );
    return { messageId: reply.messageId, threadId: reply.threadId };
  },
});

import { defineTool } from "eve/tools";
import { z } from "zod";
import { agentmail, INBOX, OPERATOR } from "../lib/agentmail";

export default defineTool({
  description:
    "Escalate a thread to a person. Saves the proposed reply as an unsent draft, " +
    "labels the thread needs-human-review, and notifies the operator by email.",
  inputSchema: z.object({
    messageId: z.string(),
    threadId: z.string(),
    proposedReply: z.string(),
    reason: z.string(),
  }),
  async execute({ messageId, threadId, proposedReply, reason }) {
    await agentmail.inboxes.drafts.create(INBOX, {
      inReplyTo: messageId,
      text: proposedReply,
    });
    await agentmail.threads.update(threadId, { addLabels: ["needs-human-review"] });
    await agentmail.inboxes.messages.forward(
      INBOX,
      messageId,
      {
        to: [OPERATOR],
        text:
          `Escalated: ${reason}\n\n` +
          `A proposed reply is saved as a draft in this thread. ` +
          `Open it in the Console, edit if needed, and send.`,
      },
      { headers: { "Idempotency-Key": `escalate-${messageId}`.replace(/[^A-Za-z0-9._~-]/g, "_") } },
    );
    return { escalated: true, reason };
  },
});

const pending = await agentmail.drafts.list(); // every unsent draft, newest first