How do I monitor what my agents are sending?

await commune.inboxes.setWebhook(domainId, inboxId, {
  endpoint: 'https://your-server.com/webhook/monitoring',
  events: [
    'email.sent',        // Email accepted by Commune
    'email.delivered',   // Email accepted by recipient's mail server
    'email.bounced',     // Email bounced (hard or soft)
    'email.complained',  // Recipient marked as spam
    'inbound',           // Reply received
  ],
});

client.inboxes.set_webhook(
    domain_id=domain_id,
    inbox_id=inbox_id,
    endpoint="https://your-server.com/webhook/monitoring",
    events=[
        "email.sent",
        "email.delivered",
        "email.bounced",
        "email.complained",
        "inbound",
    ],
)

import express from 'express';

interface InboxMetrics {
  sent: number;
  delivered: number;
  bounced: number;
  complained: number;
  lastEvent: string;
}

const metrics: Record<string, InboxMetrics> = {};

function getMetrics(inboxId: string): InboxMetrics {
  if (!metrics[inboxId]) {
    metrics[inboxId] = {
      sent: 0, delivered: 0, bounced: 0, complained: 0,
      lastEvent: new Date().toISOString(),
    };
  }
  return metrics[inboxId];
}

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

app.post('/webhook/monitoring', async (req, res) => {
  const { event, message_id, inbox_id, data } = req.body;
  const m = getMetrics(inbox_id);
  m.lastEvent = new Date().toISOString();

  switch (event) {
    case 'email.sent':
      m.sent++;
      break;

    case 'email.delivered':
      m.delivered++;
      break;

    case 'email.bounced':
      m.bounced++;
      const bounceRate = m.bounced / m.sent;
      if (bounceRate > 0.05) {
        await alert({
          level: 'critical',
          inbox: inbox_id,
          message: `Bounce rate ${(bounceRate * 100).toFixed(1)}% exceeds 5% threshold`,
          metric: { sent: m.sent, bounced: m.bounced },
        });
      }
      break;

    case 'email.complained':
      m.complained++;
      const complaintRate = m.complained / m.sent;
      if (complaintRate > 0.001) {
        await alert({
          level: 'critical',
          inbox: inbox_id,
          message: `Complaint rate ${(complaintRate * 100).toFixed(3)}% exceeds 0.1% threshold`,
          metric: { sent: m.sent, complained: m.complained },
        });
      }
      break;
  }

  // Store for audit trail
  await db.emailEvents.insert({
    event,
    message_id,
    inbox_id,
    data,
    timestamp: new Date(),
  });

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

async function alert(payload: object) {
  // Send to Slack, PagerDuty, email, etc.
  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text: JSON.stringify(payload, null, 2) }),
  });
}

from flask import Flask, request, jsonify
from datetime import datetime
from collections import defaultdict

app = Flask(__name__)

metrics = defaultdict(lambda: {
    "sent": 0, "delivered": 0, "bounced": 0,
    "complained": 0, "last_event": None,
})

@app.post("/webhook/monitoring")
def monitoring_webhook():
    payload = request.json
    event = payload["event"]
    inbox_id = payload["inbox_id"]
    message_id = payload["message_id"]

    m = metrics[inbox_id]
    m["last_event"] = datetime.utcnow().isoformat()

    if event == "email.sent":
        m["sent"] += 1

    elif event == "email.delivered":
        m["delivered"] += 1

    elif event == "email.bounced":
        m["bounced"] += 1
        bounce_rate = m["bounced"] / m["sent"]
        if bounce_rate > 0.05:
            alert(
                level="critical",
                inbox=inbox_id,
                message=f"Bounce rate {bounce_rate:.1%} exceeds 5% threshold",
            )

    elif event == "email.complained":
        m["complained"] += 1
        complaint_rate = m["complained"] / m["sent"]
        if complaint_rate > 0.001:
            alert(
                level="critical",
                inbox=inbox_id,
                message=f"Complaint rate {complaint_rate:.3%} exceeds 0.1% threshold",
            )

    # Store for audit trail
    db.email_events.insert_one({
        "event": event,
        "message_id": message_id,
        "inbox_id": inbox_id,
        "data": payload.get("data"),
        "timestamp": datetime.utcnow(),
    })

    return jsonify({"ok": True})

async function dailyHealthReport() {
  const { data: inboxes } = await commune.inboxes.list();
  const issues: string[] = [];

  for (const inbox of inboxes) {
    const { health } = inbox;

    if (health.bounceRate > 0.03) {
      issues.push(`${inbox.address}: bounce rate ${(health.bounceRate * 100).toFixed(1)}%`);
    }
    if (health.complaintRate > 0.0005) {
      issues.push(`${inbox.address}: complaint rate ${(health.complaintRate * 100).toFixed(3)}%`);
    }
    if (health.deliveryRate < 0.95) {
      issues.push(`${inbox.address}: delivery rate ${(health.deliveryRate * 100).toFixed(1)}%`);
    }
  }

  if (issues.length > 0) {
    await sendSlackAlert(`Daily email health report:\n${issues.join('\n')}`);
  }
}

async def daily_health_report():
    inboxes = client.inboxes.list()
    issues = []

    for inbox in inboxes.data:
        health = inbox.health

        if health.bounce_rate > 0.03:
            issues.append(f"{inbox.address}: bounce rate {health.bounce_rate:.1%}")
        if health.complaint_rate > 0.0005:
            issues.append(f"{inbox.address}: complaint rate {health.complaint_rate:.3%}")
        if health.delivery_rate < 0.95:
            issues.append(f"{inbox.address}: delivery rate {health.delivery_rate:.1%}")

    if issues:
        await send_slack_alert(f"Daily email health report:\n" + "\n".join(issues))