Outbound Email for AI Agents in Intercom

import httpx

MULTIMAIL_API_KEY = "mm_live_your_key_here"
BASE_URL = "https://api.multimail.dev"

def send_agent_followup(conversation_id: str, customer_email: str, draft_body: str) -> dict:
    """
    Called from an Intercom webhook handler after Fin resolves a conversation.
    Routes the follow-up email through MultiMail with gated_send oversight.
    """
    payload = {
        "from": "[email protected]",
        "to": customer_email,
        "subject": "Following up on your support request",
        "body": draft_body,
        "oversight_mode": "gated_send",
        "metadata": {
            "source": "intercom",
            "conversation_id": conversation_id,
            "agent": "fin"
        }
    }

    response = httpx.post(
        f"{BASE_URL}/send_email",
        json=payload,
        headers={"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}
    )
    response.raise_for_status()
    result = response.json()

    "cm"># result["message_id"] can be stored against conversation_id
    "cm"># for later approval status polling or webhook correlation
    return result

import httpx
from typing import Literal

MULTIMAIL_API_KEY = "mm_live_your_key_here"
BASE_URL = "https://api.multimail.dev"

def get_pending_messages() -> list[dict]:
    response = httpx.get(
        f"{BASE_URL}/list_pending",
        headers={"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}
    )
    response.raise_for_status()
    return response.json()["messages"]

def review_message(
    message_id: str,
    decision: Literal["approve", "reject"],
    reviewer: str,
    note: str = ""
) -> dict:
    """
    Approve or reject an agent-drafted outbound email.
    On approve, MultiMail delivers the message and signs it with DKIM.
    On reject, the message is cancelled and logged with the reviewer&"cm">#039;s note.
    """
    response = httpx.post(
        f"{BASE_URL}/decide_email",
        json={
            "message_id": message_id,
            "decision": decision,
            "reviewer": reviewer,
            "note": note
        },
        headers={"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}
    )
    response.raise_for_status()
    return response.json()

# Example: approve the first pending message
pending = get_pending_messages()
if pending:
    result = review_message(
        message_id=pending[0]["message_id"],
        decision="approve",
        reviewer="[email protected]"
    )
    print(result["status"])  # "delivered"

import express from 'express';
import crypto from 'crypto';

const app = express();
app.use(express.json());

const MULTIMAIL_API_KEY = process.env.MULTIMAIL_API_KEY;
const INTERCOM_SECRET = process.env.INTERCOM_CLIENT_SECRET;
const MULTIMAIL_BASE = 'https://api.multimail.dev';

"cm">// Verify Intercom webhook signature
function verifyIntercomSignature(rawBody, signature) {
  const digest = crypto
    .createHmac('sha1', INTERCOM_SECRET)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(`sha1=${digest}`),
    Buffer.from(signature)
  );
}

app.post('/webhooks/intercom', express.raw({ type: 'application/json' }), async (req, res) => {
  const sig = req.headers['x-hub-signature'];
  if (!verifyIntercomSignature(req.body, sig)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const event = JSON.parse(req.body);

  if (event.topic === 'conversation.resolved' && event.data?.item?.source?.author?.type === 'bot') {
    const conversation = event.data.item;
    const customerEmail = conversation.contacts?.contacts?.[0]?.email;
    const summary = conversation.source?.body ?? '';

    if (customerEmail && summary) {
      const response = await fetch(`${MULTIMAIL_BASE}/send_email`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${MULTIMAIL_API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          from: '[email protected]',
          to: customerEmail,
          subject: 'Your support case has been resolved',
          body: summary,
          oversight_mode: 'gated_send',
          metadata: {
            source: 'intercom',
            conversation_id: conversation.id
          }
        })
      });

      const result = await response.json();
      console.log('Queued for approval:', result.message_id);
    }
  }

  res.json({ received: true });
});

app.listen(3000);

import httpx

MULTIMAIL_API_KEY = "mm_live_your_key_here"
BASE_URL = "https://api.multimail.dev"

def provision_bot_mailbox(alias: str, display_name: str) -> dict:
    """
    Creates a dedicated mailbox for Intercom AI agent outbound email.
    Replies to this address route through MultiMail&"cm">#039;s inbound pipeline.
    """
    response = httpx.post(
        f"{BASE_URL}/create_mailbox",
        json={
            "address": f"{alias}@multimail.dev",
            "display_name": display_name,
            "oversight_mode": "gated_send",
            "webhook_url": "https://yourapp.com/webhooks/multimail"
        },
        headers={"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}
    )
    response.raise_for_status()
    return response.json()

mailbox = provision_bot_mailbox(
    alias="intercom-bot",
    display_name="Support Bot (via Intercom)"
)
print(mailbox["address"])   # [email protected]
print(mailbox["mailbox_id"]) "cm"># use this when calling send_email