Give a Vercel AI SDK agent its own inbox

bun add ai @ai-sdk/mcp

import { createMCPClient } from "@ai-sdk/mcp";
import { generateText, isStepCount } from "ai";

const mcpClient = await createMCPClient({
  transport: {
    type: "http",
    url: "https://shipmail.to/api/mcp",
    headers: { Authorization: `Bearer ${process.env.SHIPMAIL_API_KEY ?? ""}` },
  },
});

try {
  const tools = await mcpClient.tools();
  const result = await generateText({
    model: "anthropic/claude-sonnet-5.5",
    tools,
    stopWhen: isStepCount(10),
    prompt:
      "List the unread mail in agent@yourdomain.com. Draft a reply to each message that needs one.",
  });
  console.log(result.text);
} finally {
  await mcpClient.close();
}

// Read-only Shipmail MCP tools run on their own. A person approves every
// other call, so a send or reply tool added later still needs approval.
const READ_ONLY = /^shipmail_(list|get|search)_/;
const needsApproval = (name: string) => !READ_ONLY.test(name);

const result = await generateText({
  model: "anthropic/claude-sonnet-5.5",
  tools,
  toolApproval: ({ toolCall }) =>
    needsApproval(toolCall.toolName) ? "user-approval" : undefined,
  stopWhen: isStepCount(10),
  prompt: "Reply to the latest email from jane@customer.com and confirm the call on Thursday.",
});

bun add ai shipmail zod

import { tool } from "ai";
import { ShipmailClient } from "shipmail";
import { z } from "zod";

const shipmail = new ShipmailClient(process.env.SHIPMAIL_API_KEY ?? "");
const MAILBOX_ID = process.env.SHIPMAIL_MAILBOX_ID ?? "";
const FROM = process.env.SHIPMAIL_FROM ?? "";

export const emailTools = {
  list_inbox: tool({
    description: "List recent messages in the agent's inbox.",
    inputSchema: z.object({
      unread_only: z.boolean().describe("Only messages nobody has opened yet"),
      limit: z.number().int().min(1).max(50),
    }),
    execute: async ({ unread_only, limit }) => {
      const page = await shipmail.mailboxes.listInboxMessages(MAILBOX_ID, {
        folder_role: "inbox",
        limit,
        not_keyword: unread_only ? "$seen" : undefined,
      });
      return page.data.map((message) => ({
        id: message.id,
        conversation_id: message.conversation_id,
        from: message.from?.[0]?.email ?? null,
        subject: message.subject,
        received_at: message.received_at,
        preview: message.preview,
      }));
    },
  }),

  read_conversation: tool({
    description: "Read every message in one conversation.",
    inputSchema: z.object({ conversation_id: z.string() }),
    execute: async ({ conversation_id }) => {
      const thread = await shipmail.mailboxes.getInboxThread(MAILBOX_ID, conversation_id);
      return thread.data.map((message) => ({
        from: message.from?.[0]?.email ?? null,
        received_at: message.received_at,
        subject: message.subject,
        // What the sender newly wrote, without the quoted history.
        text: message.reply_text ?? message.preview,
      }));
    },
  }),

  send_email: tool({
    description: "Send a new email from the agent's address.",
    inputSchema: z.object({
      to: z.array(z.string()).min(1),
      subject: z.string(),
      text: z.string(),
    }),
    execute: async ({ to, subject, text }, { toolCallId }) => {
      const message = await shipmail.messages.send(
        { from: FROM, to, subject, text },
        // A retried call with the same ID sends nothing twice.
        { idempotencyKey: toolCallId },
      );
      return { id: message.id, status: message.status };
    },
  }),

  reply: tool({
    description: "Reply in an existing conversation.",
    inputSchema: z.object({
      conversation_id: z.string(),
      to: z.array(z.string()).min(1),
      text: z.string(),
    }),
    execute: async ({ conversation_id, to, text }, { toolCallId }) => {
      const message = await shipmail.mailboxes.replyToInboxThread(
        MAILBOX_ID,
        conversation_id,
        { to, text },
        { idempotencyKey: toolCallId },
      );
      return { id: message.id, status: message.status };
    },
  }),
};

import { createInterface } from "node:readline/promises";
import { generateText, isStepCount, type ModelMessage, type ToolApprovalResponse } from "ai";

import { emailTools } from "./email-tools";

function run(messages: ModelMessage[]) {
  return generateText({
    model: "anthropic/claude-sonnet-5.5",
    tools: emailTools,
    // Reading runs on its own. Sending waits for a person.
    toolApproval: { send_email: "user-approval", reply: "user-approval" },
    stopWhen: isStepCount(10),
    messages,
  });
}

const messages: ModelMessage[] = [
  { role: "user", content: "Reply to the latest email from jane@customer.com and confirm the call on Thursday." },
];

let result = await run(messages);
messages.push(...result.responseMessages);

const rl = createInterface({ input: process.stdin, output: process.stdout });
const approvals: ToolApprovalResponse[] = [];
for (const part of result.content) {
  if (part.type === "tool-approval-request" && !part.isAutomatic) {
    const answer = await rl.question(
      `Allow ${part.toolCall.toolName} ${JSON.stringify(part.toolCall.input)}? (y/n) `,
    );
    approvals.push({
      type: "tool-approval-response",
      approvalId: part.approvalId,
      approved: answer.trim().toLowerCase() === "y",
    });
  }
}
rl.close();

if (approvals.length > 0) {
  messages.push({ role: "tool", content: approvals });
  result = await run(messages);
}
console.log(result.text);