Durable Email Delivery for Trigger.dev Workflows

import { task } from '@trigger.dev/sdk/v3';

export const sendCompletionEmail = task({
  id: 'send-completion-email',
  retry: { maxAttempts: 3, backoffFactor: 2 },
  run: async (payload: {
    to: string;
    jobId: string;
    summary: string;
  }) => {
    const res = await fetch('https://api.multimail.dev/send_email', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.MULTIMAIL_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        from: '[email protected]',
        to: payload.to,
        subject: `Job ${payload.jobId} completed`,
        text: payload.summary,
        idempotency_key: `job-complete-${payload.jobId}`,
      }),
    });

    if (!res.ok) {
      throw new Error(`send_email failed: ${res.status} ${res.statusText}`);
    }

    return res.json();
  },
});

import { schedules } from '@trigger.dev/sdk/v3';

const API = 'https://api.multimail.dev';
const headers = {
  Authorization: `Bearer ${process.env.MULTIMAIL_API_KEY}`,
  'Content-Type': 'application/json',
};

export const processInbox = schedules.task({
  id: 'process-inbox-hourly',
  cron: '0 * * * *',
  run: async () => {
    const inboxRes = await fetch(
      `${API}/[email protected]&unread=true`,
      { headers },
    );
    if (!inboxRes.ok) throw new Error(`check_inbox: ${inboxRes.status}`);

    const { emails } = await inboxRes.json();

    for (const email of emails) {
      const readRes = await fetch(`${API}/read_email?id=${email.id}`, { headers });
      if (!readRes.ok) throw new Error(`read_email ${email.id}: ${readRes.status}`);

      const message = await readRes.json();

      await fetch(`${API}/tag_email`, {
        method: 'POST',
        headers,
        body: JSON.stringify({ id: email.id, tags: ['processed'] }),
      });

      console.log('Processed:', message.subject);
    }

    return { processed: emails.length };
  },
});

import { task, wait } from '@trigger.dev/sdk/v3';

const BASE = 'https://api.multimail.dev';
const auth = () => ({
  Authorization: `Bearer ${process.env.MULTIMAIL_API_KEY}`,
  'Content-Type': 'application/json',
});

export const sendGatedEmail = task({
  id: 'send-gated-email',
  run: async (payload: { to: string; subject: string; body: string }) => {
    "cm">// Mailbox is in gated_send mode — send_email queues rather than delivers
    const sendRes = await fetch(`${BASE}/send_email`, {
      method: 'POST',
      headers: auth(),
      body: JSON.stringify({
        from: '[email protected]',
        to: payload.to,
        subject: payload.subject,
        text: payload.body,
      }),
    });
    if (!sendRes.ok) throw new Error(`send_email: ${sendRes.status}`);
    const { message_id } = await sendRes.json();

    "cm">// Suspend for up to 24 hours while a human reviews
    await wait.for({ hours: 24 });

    const pendingRes = await fetch(`${BASE}/list_pending`, { headers: auth() });
    const { pending } = await pendingRes.json();
    const stillPending = pending.find((m: { id: string }) => m.id === message_id);

    return {
      message_id,
      status: stillPending ? 'awaiting_approval' : 'delivered_or_cancelled',
    };
  },
});

import { task } from '@trigger.dev/sdk/v3';

export const replyToThread = task({
  id: 'reply-to-thread',
  run: async (payload: { thread_id: string; reply_text: string }) => {
    const API = 'https://api.multimail.dev';
    const headers = {
      Authorization: `Bearer ${process.env.MULTIMAIL_API_KEY}`,
      'Content-Type': 'application/json',
    };

    "cm">// Load the thread to get the latest message ID
    const threadRes = await fetch(`${API}/get_thread?id=${payload.thread_id}`, { headers });
    if (!threadRes.ok) throw new Error(`get_thread: ${threadRes.status}`);
    const { messages } = await threadRes.json();
    const latest = messages[messages.length - 1];

    "cm">// Reply in-thread
    const replyRes = await fetch(`${API}/reply_email`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        reply_to_id: latest.id,
        text: payload.reply_text,
      }),
    });
    if (!replyRes.ok) throw new Error(`reply_email: ${replyRes.status}`);

    return replyRes.json();
  },
});