What happens if my agent sends too many emails?

async function sendWithBackoff(
  payload: SendEmailPayload,
  maxRetries = 5,
): Promise<void> {
  let attempt = 0;

  while (attempt < maxRetries) {
    try {
      await commune.messages.send(payload);
      return;
    } catch (err: any) {
      if (err.status === 429) {
        const retryAfter = err.body?.retryAfter ?? 60;
        const backoff = retryAfter * Math.pow(2, attempt);
        console.log(`Rate limited. Retrying in ${backoff}s (attempt ${attempt + 1})`);
        await sleep(backoff * 1000);
        attempt++;
      } else {
        throw err;
      }
    }
  }

  throw new Error(`Failed to send email after ${maxRetries} attempts`);
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

import time
import math

def send_with_backoff(payload: dict, max_retries: int = 5) -> None:
    attempt = 0

    while attempt < max_retries:
        try:
            client.messages.send(**payload)
            return
        except CommuneRateLimitError as err:
            retry_after = getattr(err, "retry_after", 60)
            backoff = retry_after * math.pow(2, attempt)
            print(f"Rate limited. Retrying in {backoff}s (attempt {attempt + 1})")
            time.sleep(backoff)
            attempt += 1

    raise RuntimeError(f"Failed to send email after {max_retries} attempts")

const recipients = [...]; // your full list

const BATCH_SIZE = 50;
const DELAY_MS = 2000; // 2 seconds between batches

for (let i = 0; i < recipients.length; i += BATCH_SIZE) {
  const batch = recipients.slice(i, i + BATCH_SIZE);

  await Promise.all(
    batch.map((recipient) =>
      sendWithBackoff({
        from: 'agent@yourdomain.com',
        to: recipient.email,
        subject: 'Your weekly digest',
        html: renderDigest(recipient),
      }),
    ),
  );

  if (i + BATCH_SIZE < recipients.length) {
    await sleep(DELAY_MS);
  }
}

import time

recipients = [...]  # your full list

BATCH_SIZE = 50
DELAY_SECONDS = 2

for i in range(0, len(recipients), BATCH_SIZE):
    batch = recipients[i : i + BATCH_SIZE]

    for recipient in batch:
        send_with_backoff({
            "from_": "agent@yourdomain.com",
            "to": recipient["email"],
            "subject": "Your weekly digest",
            "html": render_digest(recipient),
        })

    if i + BATCH_SIZE < len(recipients):
        time.sleep(DELAY_SECONDS)