DelayKit

// the call timed out, so you don't know whether Stripe processed it.
// retry with the SAME idempotency key. Stripe returns the cached
// result if the original succeeded, so the customer is never charged
// twice. don't auto-retry card_declined — the bank already said no
// and the cached error will come back unchanged.
try {
  await stripe.paymentIntents.create(
    { amount, customer, confirm: true },
    { idempotencyKey: `charge-${order.id}` },
  );
} catch (err) {
  if (isTransientError(err)) {
    await dk.schedule("retry-charge", { key: order.id, delay: "30s" });
  }
}

dk.handle("retry-charge", {
  handler: async ({ key }) => {
    const order = await db.orders.find(key);
    if (order.status === "paid") return; // resolved by another path

    await stripe.paymentIntents.create(
      { amount: order.amount, customer: order.customerId, confirm: true },
      { idempotencyKey: `charge-${key}` }, // SAME key as the original
    );
  },
  retry: { attempts: 3, backoff: "exponential" },
});

// after Smart Retries exhaust (or if you've turned it off),
// run your own dunning schedule. each attempt is a NEW payment,
// so each gets its own idempotency key. reusing the key would
// dedupe back to the first failure and never actually retry.
dk.handle("retry-invoice", async ({ key }) => {
  const [invoiceId, attempt] = key.split(":");
  const invoice = await stripe.invoices.retrieve(invoiceId);
  if (invoice.status !== "open") return; // paid or voided

  await stripe.invoices.pay(invoiceId, undefined, {
    idempotencyKey: `dunning-${invoiceId}-${attempt}`,
  });
});