Give a Mastra agent its own inbox

bun add @mastra/core@latest @mastra/mcp@latest

import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";

// 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);

export const shipmailMcp = new MCPClient({
  id: "shipmail-mcp",
  servers: {
    shipmail: {
      url: new URL("https://shipmail.to/api/mcp"),
      requestInit: {
        headers: { Authorization: `Bearer ${process.env.SHIPMAIL_API_KEY ?? ""}` },
      },
      requireToolApproval: ({ toolName }) => needsApproval(toolName),
    },
  },
});

export const inboxAgent = new Agent({
  id: "inbox-agent",
  name: "Inbox agent",
  instructions: "You answer the mail of agent@yourdomain.com. Read the whole conversation before you reply.",
  model: "openai/gpt-6.1-sol",
  tools: await shipmailMcp.listTools(),
});

bun add @mastra/core@latest shipmail zod

import { createTool } from "@mastra/core/tools";
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 listInbox = createTool({
  id: "list-inbox",
  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,
    }));
  },
});

export const readConversation = createTool({
  id: "read-conversation",
  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,
    }));
  },
});

export const sendEmail = createTool({
  id: "send-email",
  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(),
  }),
  requireApproval: true,
  execute: async ({ to, subject, text }) => {
    const message = await shipmail.messages.send({ from: FROM, to, subject, text });
    return { id: message.id, status: message.status };
  },
});

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

import { Agent } from "@mastra/core/agent";

import { listInbox, readConversation, reply, sendEmail } from "./email-tools";

export const inboxAgent = new Agent({
  id: "inbox-agent",
  name: "Inbox agent",
  instructions: "You answer the mail of agent@yourdomain.com. Read the whole conversation before you reply.",
  model: "openai/gpt-6.1-sol",
  tools: { listInbox, readConversation, sendEmail, reply },
});

import { createInterface } from "node:readline/promises";

import { inboxAgent } from "./agent";

const rl = createInterface({ input: process.stdin, output: process.stdout });
const stream = await inboxAgent.stream(
  "Reply to the latest email from jane@customer.com and confirm the call on Thursday.",
);

for await (const chunk of stream.fullStream) {
  if (chunk.type === "tool-call-approval") {
    const answer = await rl.question(
      `Allow ${chunk.payload.toolName} ${JSON.stringify(chunk.payload.args)}? (y/n) `,
    );
    const next =
      answer.trim().toLowerCase() === "y"
        ? await inboxAgent.approveToolCall({ runId: stream.runId })
        : await inboxAgent.declineToolCall({ runId: stream.runId });
    for await (const text of next.textStream) process.stdout.write(text);
  }
}
rl.close();