How do I prevent my agent from sending duplicate emails?

import { createHash } from 'crypto';
import { CommuneClient } from 'commune-ai';

const commune = new CommuneClient({ apiKey: process.env.COMMUNE_API_KEY! });

// Deterministic key: hash of thread + recipient + intent
function idempotencyKey(threadId: string, to: string, intent: string): string {
  return createHash('sha256')
    .update(`${threadId}:${to}:${intent}`)
    .digest('hex')
    .slice(0, 48);
}

await commune.messages.send({
  to: 'customer@example.com',
  subject: 'Your order has shipped',
  inboxId: 'inb_orders_01',
  threadId: 'thr_01XYZ',
  text: 'Your order #8842 shipped today.',
  headers: {
    'Idempotency-Key': idempotencyKey('thr_01XYZ', 'customer@example.com', 'shipment_notification'),
  },
});

import hashlib
import commune

client = commune.CommuneClient(api_key=os.environ["COMMUNE_API_KEY"])

def idempotency_key(thread_id: str, to: str, intent: str) -> str:
    """Deterministic key: hash of thread + recipient + intent."""
    raw = f"{thread_id}:{to}:{intent}"
    return hashlib.sha256(raw.encode()).hexdigest()[:48]

client.messages.send(
    to="customer@example.com",
    subject="Your order has shipped",
    inbox_id="inb_orders_01",
    thread_id="thr_01XYZ",
    text="Your order #8842 shipped today.",
    headers={
        "Idempotency-Key": idempotency_key(
            "thr_01XYZ", "customer@example.com", "shipment_notification"
        ),
    },
)

// Before sending, check if we already sent this
async function sendOnce(params: {
  dedupeKey: string;
  to: string;
  subject: string;
  text: string;
  inboxId: string;
  threadId?: string;
}) {
  // Check your database
  const existing = await db.agentSends.findOne({ dedupeKey: params.dedupeKey });
  if (existing) {
    console.log(`Already sent: ${params.dedupeKey}`);
    return existing.result;
  }

  // Send
  const result = await commune.messages.send({
    to: params.to,
    subject: params.subject,
    inboxId: params.inboxId,
    threadId: params.threadId,
    text: params.text,
    headers: {
      'Idempotency-Key': params.dedupeKey,
    },
  });

  // Record the send
  await db.agentSends.insertOne({
    dedupeKey: params.dedupeKey,
    result,
    sentAt: new Date(),
  });

  return result;
}

def send_once(
    dedupe_key: str,
    to: str,
    subject: str,
    text: str,
    inbox_id: str,
    thread_id: str | None = None,
) -> dict:
    """Send an email only if we haven't already sent one with this key."""
    # Check your database
    existing = db.agent_sends.find_one({"dedupe_key": dedupe_key})
    if existing:
        print(f"Already sent: {dedupe_key}")
        return existing["result"]

    # Send
    result = client.messages.send(
        to=to,
        subject=subject,
        inbox_id=inbox_id,
        thread_id=thread_id,
        text=text,
        headers={
            "Idempotency-Key": dedupe_key,
        },
    )

    # Record the send
    db.agent_sends.insert_one({
        "dedupe_key": dedupe_key,
        "result": result,
        "sent_at": datetime.utcnow(),
    })

    return result

app.post('/webhook', async (req, res) => {
  const { message } = req.body;

  // Only respond to inbound messages — ignore our own outbound emails
  if (message.direction !== 'inbound') {
    return res.json({ ok: true, skipped: 'outbound' });
  }

  // Safe to generate a reply
  const reply = await agent.generateReply(message);
  await commune.messages.send({ /* ... */ });
  res.json({ ok: true });
});

@app.post("/webhook")
def handle_webhook(payload: dict):
    message = payload["message"]

    # Only respond to inbound messages — ignore our own outbound emails
    if message["direction"] != "inbound":
        return {"ok": True, "skipped": "outbound"}

    # Safe to generate a reply
    reply = agent.generate_reply(message)
    client.messages.send(...)
    return {"ok": True}

app.post('/webhook', async (req, res) => {
  const { message } = req.body;
  if (message.direction !== 'inbound') {
    return res.json({ ok: true });
  }

  // Dedup: have we already replied to this exact message?
  const alreadyReplied = await db.replies.findOne({
    inboundMessageId: message.message_id,
  });
  if (alreadyReplied) {
    return res.json({ ok: true, skipped: 'already_replied' });
  }

  const reply = await agent.generateReply(message);
  await commune.messages.send({ /* ... */ });

  await db.replies.insertOne({
    inboundMessageId: message.message_id,
    repliedAt: new Date(),
  });

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

@app.post("/webhook")
def handle_webhook(payload: dict):
    message = payload["message"]
    if message["direction"] != "inbound":
        return {"ok": True}

    # Dedup: have we already replied to this exact message?
    already_replied = db.replies.find_one({
        "inbound_message_id": message["message_id"],
    })
    if already_replied:
        return {"ok": True, "skipped": "already_replied"}

    reply = agent.generate_reply(message)
    client.messages.send(...)

    db.replies.insert_one({
        "inbound_message_id": message["message_id"],
        "replied_at": datetime.utcnow(),
    })

    return {"ok": True}