Send us a lead with one POST.

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"first_name": "Dana", "last_name": "Whitfield", "phone": "6305550142",
	})
	req, _ := http.NewRequest(http.MethodPost, "https://intake.hellojade.ai/v1/intake", bytes.NewReader(body))
	req.Header.Set("X-API-Key", os.Getenv("HELLOJADE_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Idempotency-Key", "acme-leads:A-99812") // YOUR stable id for the lead
	req.Header.Set("X-Request-Id", "acme-leads/A-99812/1")

	client := &http.Client{Timeout: 20 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		panic(err) // transport error: safe to retry with the same Idempotency-Key
	}
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, resp.Header.Get("X-Request-Id"), string(out))
	// 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off
}

const res = await fetch('https://intake.hellojade.ai/v1/intake', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.HELLOJADE_API_KEY,
    'Content-Type': 'application/json',
    'Idempotency-Key': 'acme-leads:A-99812',   // YOUR stable id for the lead
    'X-Request-Id': 'acme-leads/A-99812/1',
  },
  body: JSON.stringify({ first_name: 'Dana', last_name: 'Whitfield', phone: '6305550142' }),
  signal: AbortSignal.timeout(20_000),
});
console.log(res.status, res.headers.get('x-request-id'), await res.json());
// 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off

import os
import requests

r = requests.post(
    "https://intake.hellojade.ai/v1/intake",
    headers={
        "X-API-Key": os.environ["HELLOJADE_API_KEY"],
        "Idempotency-Key": "acme-leads:A-99812",   # YOUR stable id for the lead
        "X-Request-Id": "acme-leads/A-99812/1",
    },
    json={"first_name": "Dana", "last_name": "Whitfield", "phone": "6305550142"},
    timeout=20,
)
print(r.status_code, r.headers.get("X-Request-Id"), r.json())
# 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off

<?php
$ch = curl_init('https://intake.hellojade.ai/v1/intake');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 20,
    CURLOPT_HTTPHEADER     => [
        'X-API-Key: ' . getenv('HELLOJADE_API_KEY'),
        'Content-Type: application/json',
        'Idempotency-Key: acme-leads:A-99812',   // YOUR stable id for the lead
        'X-Request-Id: acme-leads/A-99812/1',
    ],
    CURLOPT_POSTFIELDS     => json_encode([
        'first_name' => 'Dana', 'last_name' => 'Whitfield', 'phone' => '6305550142',
    ]),
]);
$body   = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
curl_close($ch);
echo $status, ' ', $body, PHP_EOL;
// 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off

require "net/http"
require "json"

uri = URI("https://intake.hellojade.ai/v1/intake")
req = Net::HTTP::Post.new(uri)
req["X-API-Key"]       = ENV.fetch("HELLOJADE_API_KEY")
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "acme-leads:A-99812"   # YOUR stable id for the lead
req["X-Request-Id"]    = "acme-leads/A-99812/1"
req.body = { first_name: "Dana", last_name: "Whitfield", phone: "6305550142" }.to_json

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 20) { |http| http.request(req) }
puts "#{res.code} #{res["X-Request-Id"]} #{res.body}"
# 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Quickstart {
    public static void main(String[] args) throws Exception {
        String body = "{\"first_name\":\"Dana\",\"last_name\":\"Whitfield\",\"phone\":\"6305550142\"}";
        HttpRequest req = HttpRequest.newBuilder(URI.create("https://intake.hellojade.ai/v1/intake"))
            .timeout(Duration.ofSeconds(20))
            .header("X-API-Key", System.getenv("HELLOJADE_API_KEY"))
            .header("Content-Type", "application/json")
            .header("Idempotency-Key", "acme-leads:A-99812")   // YOUR stable id for the lead
            .header("X-Request-Id", "acme-leads/A-99812/1")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.statusCode() + " "
            + res.headers().firstValue("x-request-id").orElse("") + " " + res.body());
        // 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off
    }
}

using System.Net.Http.Json;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(20) };
using var req  = new HttpRequestMessage(HttpMethod.Post, "https://intake.hellojade.ai/v1/intake");
req.Headers.Add("X-API-Key", Environment.GetEnvironmentVariable("HELLOJADE_API_KEY"));
req.Headers.Add("Idempotency-Key", "acme-leads:A-99812");   // YOUR stable id for the lead
req.Headers.Add("X-Request-Id", "acme-leads/A-99812/1");
req.Content = JsonContent.Create(new { first_name = "Dana", last_name = "Whitfield", phone = "6305550142" });

using var res = await http.SendAsync(req);
var requestId = res.Headers.TryGetValues("X-Request-Id", out var v) ? string.Join(",", v) : "";
Console.WriteLine($"{(int)res.StatusCode} {requestId} {await res.Content.ReadAsStringAsync()}");
// 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }
//             tokio = { version = "1", features = ["full"] }   serde_json = "1"
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = reqwest::Client::builder().timeout(Duration::from_secs(20)).build()?;
    let res = client
        .post("https://intake.hellojade.ai/v1/intake")
        .header("X-API-Key", std::env::var("HELLOJADE_API_KEY").expect("HELLOJADE_API_KEY"))
        .header("Idempotency-Key", "acme-leads:A-99812")   // YOUR stable id for the lead
        .header("X-Request-Id", "acme-leads/A-99812/1")
        .json(&serde_json::json!({ "first_name": "Dana", "last_name": "Whitfield", "phone": "6305550142" }))
        .send()
        .await?;
    let request_id = res.headers().get("x-request-id")
        .and_then(|v| v.to_str().ok()).unwrap_or("").to_string();
    println!("{} {} {}", res.status(), request_id, res.text().await?);
    // 202 accepted · 200 duplicate · 422 read .fields · 429 wait Retry-After · 5xx back off
    Ok(())
}

package intake

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math/rand/v2"
	"net/http"
	"os"
	"strconv"
	"time"
)

const endpoint = "https://intake.hellojade.ai/v1/intake"

// SendLead posts one lead and returns its event_id. leadID is YOUR stable id
// for the lead — it becomes the Idempotency-Key, which is what makes every
// retry below safe.
func SendLead(ctx context.Context, client *http.Client, lead map[string]any, leadID string) (string, error) {
	body, err := json.Marshal(lead)
	if err != nil {
		return "", err
	}
	const maxAttempts = 5
	rateWaits := 0
	for attempt := 1; attempt <= maxAttempts; attempt++ {
		req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
		if err != nil {
			return "", err
		}
		req.Header.Set("X-API-Key", os.Getenv("HELLOJADE_API_KEY"))
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("Idempotency-Key", "acme-leads:"+leadID) // rules 2 + 3: ours, namespaced, stable
		req.Header.Set("X-Request-Id", fmt.Sprintf("acme-leads/%s/%d", leadID, attempt))

		resp, err := client.Do(req)
		if err != nil {
			// Transport error or timeout. Safe to retry: the same Idempotency-Key
			// cannot create a duplicate even if the request actually arrived.
			if attempt == maxAttempts {
				return "", err
			}
			sleep(ctx, backoff(attempt))
			continue
		}
		respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
		resp.Body.Close()

		switch {
		case resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusOK:
			// 202 accepted, 200 duplicate — both mean it is on their disk.
			var out map[string]any
			if err := json.Unmarshal(respBody, &out); err != nil {
				return "", err
			}
			id, _ := out["event_id"].(string)
			return id, nil
		case resp.StatusCode == http.StatusTooManyRequests:
			// Retry-After is a floor of 1s. Grow our own wait, and do not spend a
			// delivery attempt on it.
			floor, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
			rateWaits++
			if rateWaits > 10 {
				return "", errors.New("intake: rate limited for too long")
			}
			sleep(ctx, max(time.Duration(floor)*time.Second, backoff(rateWaits)))
			attempt--
		case resp.StatusCode >= 500:
			if attempt == maxAttempts {
				return "", fmt.Errorf("intake %d", resp.StatusCode)
			}
			sleep(ctx, backoff(attempt))
		default:
			// Any other 4xx is OUR bug; retrying will not fix it. Keep request_id —
			// it is the only handle support can use when there is no event_id.
			return "", fmt.Errorf("intake rejected the lead (%d, request_id=%s): %s",
				resp.StatusCode, resp.Header.Get("X-Request-Id"), respBody)
		}
	}
	return "", errors.New("unreachable")
}

// backoff is exponential with a 30s cap and up to 500ms of jitter, so a fleet
// of workers recovering from the same outage does not retry in lockstep.
func backoff(n int) time.Duration {
	d := min(time.Duration(1<<(n-1))*time.Second, 30*time.Second)
	return d + time.Duration(rand.IntN(500))*time.Millisecond
}

func sleep(ctx context.Context, d time.Duration) {
	select {
	case <-ctx.Done():
	case <-time.After(d):
	}
}

const ENDPOINT = 'https://intake.hellojade.ai/v1/intake';

// Returns the event_id. leadId is YOUR stable id for the lead — it becomes the
// Idempotency-Key, which is what makes every retry below safe.
async function sendLead(lead, leadId) {
  const MAX_ATTEMPTS = 5;
  let rateLimitWaits = 0;

  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
    let res;
    try {
      res = await fetch(ENDPOINT, {
        method: 'POST',
        headers: {
          'X-API-Key': process.env.HELLOJADE_API_KEY,
          'Content-Type': 'application/json',
          // Rules 2 + 3: OUR id for the lead, namespaced to us, stable across retries.
          'Idempotency-Key': 'acme-leads:' + leadId,
          // Make support answerable.
          'X-Request-Id': 'acme-leads/' + leadId + '/' + attempt,
        },
        body: JSON.stringify(lead),
        signal: AbortSignal.timeout(20_000),
      });
    } catch (err) {
      // Network error or timeout. Safe to retry — the same Idempotency-Key
      // means we cannot create a duplicate even if it actually arrived.
      if (attempt === MAX_ATTEMPTS) throw err;
      await sleep(backoff(attempt));
      continue;
    }

    if (res.status === 202 || res.status === 200) {
      const { event_id, flags } = await res.json();
      if (flags?.length) console.info('accepted with flags', { leadId, event_id, flags });
      return event_id;                       // done — it is on their disk
    }

    if (res.status === 429) {
      // Retry-After is a floor of 1s. Grow our own wait so a sustained limit
      // does not become a hot loop, and do not spend a delivery attempt on it.
      const floor = Number(res.headers.get('Retry-After') || 1);
      await sleep(Math.max(floor * 1000, backoff(++rateLimitWaits)));
      attempt--;
      if (rateLimitWaits > 10) throw new Error('intake: rate limited for too long');
      continue;
    }

    if (res.status >= 500) {
      if (attempt === MAX_ATTEMPTS) throw new Error('intake ' + res.status);
      await sleep(backoff(attempt));
      continue;
    }

    // Any other 4xx is OUR bug. Retrying will not fix it. Keep request_id —
    // it is the only handle support can use when there is no event_id.
    const body = await res.text();
    const reqId = res.headers.get('X-Request-Id');
    throw new Error('intake rejected the lead (' + res.status + ', request_id=' + reqId + '): ' + body);
  }
}

// Jitter matters: without it a fleet of workers recovering from the same
// outage retries in lockstep and turns a blip into a thundering herd.
const backoff = n => Math.min(30_000, 1000 * 2 ** (n - 1)) + Math.random() * 500;
const sleep = ms => new Promise(r => setTimeout(r, ms));

import os
import random
import time

import requests

ENDPOINT = "https://intake.hellojade.ai/v1/intake"
MAX_ATTEMPTS = 5


class IntakeRejected(Exception):
    """A 4xx other than 429: the body needs fixing. Never retried."""


def backoff(n: int) -> float:
    # Exponential, 30 s cap, up to 0.5 s of jitter so workers do not retry in lockstep.
    return min(30.0, 2.0 ** (n - 1)) + random.random() * 0.5


def send_lead(lead: dict, lead_id: str) -> str:
    """POST one lead; return its event_id. lead_id is YOUR stable id (the Idempotency-Key)."""
    rate_waits = 0
    attempt = 1
    while attempt <= MAX_ATTEMPTS:
        headers = {
            "X-API-Key": os.environ["HELLOJADE_API_KEY"],
            "Idempotency-Key": f"acme-leads:{lead_id}",        # rules 2 + 3: ours, namespaced, stable
            "X-Request-Id": f"acme-leads/{lead_id}/{attempt}",
        }
        try:
            r = requests.post(ENDPOINT, json=lead, headers=headers, timeout=20)
        except requests.RequestException:
            # Transport error or timeout: safe to retry, the key cannot duplicate.
            if attempt == MAX_ATTEMPTS:
                raise
            time.sleep(backoff(attempt))
            attempt += 1
            continue

        if r.status_code in (202, 200):        # accepted, or a duplicate we already had
            data = r.json()
            if data.get("flags"):
                print("accepted with flags", lead_id, data["event_id"], data["flags"])
            return data["event_id"]

        if r.status_code == 429:
            rate_waits += 1
            if rate_waits > 10:
                raise RuntimeError("intake: rate limited for too long")
            floor = float(r.headers.get("Retry-After", "1"))
            time.sleep(max(floor, backoff(rate_waits)))
            continue                            # a 429 does not consume an attempt

        if r.status_code >= 500:
            if attempt == MAX_ATTEMPTS:
                raise RuntimeError(f"intake {r.status_code}")
            time.sleep(backoff(attempt))
            attempt += 1
            continue

        # Any other 4xx is our bug; keep request_id for support.
        raise IntakeRejected(
            f"intake rejected the lead ({r.status_code}, "
            f"request_id={r.headers.get('X-Request-Id')}): {r.text}"
        )
    raise RuntimeError("unreachable")

<?php
const ENDPOINT     = 'https://intake.hellojade.ai/v1/intake';
const MAX_ATTEMPTS = 5;

// Exponential, 30 s cap, up to 0.5 s of jitter so workers do not retry in lockstep.
function backoff(int $n): float { return min(30.0, 2 ** ($n - 1)) + mt_rand(0, 500) / 1000; }

/** POST one lead; returns its event_id. $leadId is YOUR stable id (the Idempotency-Key). */
function sendLead(array $lead, string $leadId): string
{
    $rateWaits = 0;
    for ($attempt = 1; $attempt <= MAX_ATTEMPTS; $attempt++) {
        $ch = curl_init(ENDPOINT);
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER         => true,
            CURLOPT_TIMEOUT        => 20,
            CURLOPT_HTTPHEADER     => [
                'X-API-Key: ' . getenv('HELLOJADE_API_KEY'),
                'Content-Type: application/json',
                'Idempotency-Key: acme-leads:' . $leadId,               // rules 2 + 3: ours, namespaced, stable
                'X-Request-Id: acme-leads/' . $leadId . '/' . $attempt,
            ],
            CURLOPT_POSTFIELDS     => json_encode($lead),
        ]);
        $raw = curl_exec($ch);
        if ($raw === false) {                                           // transport error or timeout: safe to retry
            curl_close($ch);
            if ($attempt === MAX_ATTEMPTS) throw new RuntimeException('intake unreachable');
            usleep((int) (backoff($attempt) * 1e6));
            continue;
        }
        $status    = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
        $headerLen = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
        curl_close($ch);
        $headers = substr($raw, 0, $headerLen);
        $body    = substr($raw, $headerLen);

        if ($status === 202 || $status === 200) {                       // accepted, or a duplicate we already had
            $data = json_decode($body, true);
            if (!empty($data['flags'])) error_log('accepted with flags: ' . implode(',', $data['flags']));
            return $data['event_id'];
        }
        if ($status === 429) {
            if (++$rateWaits > 10) throw new RuntimeException('intake: rate limited for too long');
            $floor = preg_match('/^Retry-After:\s*(\d+)/mi', $headers, $m) ? (int) $m[1] : 1;
            usleep((int) (max($floor, backoff($rateWaits)) * 1e6));
            $attempt--;                                                  // a 429 does not consume an attempt
            continue;
        }
        if ($status >= 500) {
            if ($attempt === MAX_ATTEMPTS) throw new RuntimeException("intake $status");
            usleep((int) (backoff($attempt) * 1e6));
            continue;
        }
        // Any other 4xx is our bug; keep request_id for support.
        preg_match('/^X-Request-Id:\s*(\S+)/mi', $headers, $m);
        throw new InvalidArgumentException(
            "intake rejected the lead ($status, request_id=" . ($m[1] ?? '') . "): $body");
    }
    throw new RuntimeException('unreachable');
}

require "net/http"
require "json"

ENDPOINT     = URI("https://intake.hellojade.ai/v1/intake")
MAX_ATTEMPTS = 5

class IntakeRejected < StandardError; end   # a 4xx other than 429: never retried

# Exponential, 30 s cap, up to 0.5 s of jitter so workers do not retry in lockstep.
def backoff(n) = [30.0, 2.0**(n - 1)].min + rand * 0.5

# POST one lead; returns its event_id. lead_id is YOUR stable id (the Idempotency-Key).
def send_lead(lead, lead_id)
  rate_waits = 0
  attempt = 1
  while attempt <= MAX_ATTEMPTS
    req = Net::HTTP::Post.new(ENDPOINT)
    req["X-API-Key"]       = ENV.fetch("HELLOJADE_API_KEY")
    req["Content-Type"]    = "application/json"
    req["Idempotency-Key"] = "acme-leads:#{lead_id}"          # rules 2 + 3: ours, namespaced, stable
    req["X-Request-Id"]    = "acme-leads/#{lead_id}/#{attempt}"
    req.body = lead.to_json

    begin
      res = Net::HTTP.start(ENDPOINT.host, ENDPOINT.port, use_ssl: true,
                            open_timeout: 20, read_timeout: 20) { |http| http.request(req) }
    rescue SystemCallError, IOError, Net::OpenTimeout, Net::ReadTimeout
      raise if attempt == MAX_ATTEMPTS               # transport error or timeout: safe to retry
      sleep backoff(attempt)
      attempt += 1
      next
    end

    case res.code.to_i
    when 202, 200                                     # accepted, or a duplicate we already had
      data = JSON.parse(res.body)
      warn "accepted with flags #{data['flags']}" if data["flags"]&.any?
      return data["event_id"]
    when 429
      rate_waits += 1
      raise "intake: rate limited for too long" if rate_waits > 10
      sleep [res["Retry-After"].to_f, backoff(rate_waits)].max
      next                                            # a 429 does not consume an attempt
    when 500..599
      raise "intake #{res.code}" if attempt == MAX_ATTEMPTS
      sleep backoff(attempt)
      attempt += 1
    else
      # Any other 4xx is our bug; keep request_id for support.
      raise IntakeRejected, "intake rejected the lead (#{res.code}, request_id=#{res['X-Request-Id']}): #{res.body}"
    end
  end
  raise "unreachable"
end

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.ThreadLocalRandom;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class Intake {
    private static final String ENDPOINT = "https://intake.hellojade.ai/v1/intake";
    private static final int MAX_ATTEMPTS = 5;
    private final HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();

    /** A 4xx other than 429: the body needs fixing. Never retried. */
    public static final class Rejected extends RuntimeException { Rejected(String m) { super(m); } }

    /** POST one lead (serialized JSON); returns its event_id. leadId is YOUR stable id (the Idempotency-Key). */
    public String sendLead(String leadJson, String leadId) throws IOException, InterruptedException {
        int rateWaits = 0;
        for (int attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
            HttpRequest req = HttpRequest.newBuilder(URI.create(ENDPOINT))
                .timeout(Duration.ofSeconds(20))
                .header("X-API-Key", System.getenv("HELLOJADE_API_KEY"))
                .header("Content-Type", "application/json")
                .header("Idempotency-Key", "acme-leads:" + leadId)              // rules 2 + 3: ours, namespaced, stable
                .header("X-Request-Id", "acme-leads/" + leadId + "/" + attempt)
                .POST(HttpRequest.BodyPublishers.ofString(leadJson))
                .build();
            HttpResponse<String> res;
            try {
                res = client.send(req, HttpResponse.BodyHandlers.ofString());
            } catch (IOException e) {                                          // transport error or timeout: safe to retry
                if (attempt == MAX_ATTEMPTS) throw e;
                Thread.sleep(backoffMs(attempt));
                continue;
            }
            int status = res.statusCode();
            if (status == 202 || status == 200) {                                // accepted, or a duplicate we already had
                return eventId(res.body());
            }
            if (status == 429) {
                if (++rateWaits > 10) throw new IOException("intake: rate limited for too long");
                long floor = Long.parseLong(res.headers().firstValue("Retry-After").orElse("1")) * 1000;
                Thread.sleep(Math.max(floor, backoffMs(rateWaits)));
                attempt--;                                                       // a 429 does not consume an attempt
                continue;
            }
            if (status >= 500) {
                if (attempt == MAX_ATTEMPTS) throw new IOException("intake " + status);
                Thread.sleep(backoffMs(attempt));
                continue;
            }
            // Any other 4xx is our bug; keep request_id for support.
            throw new Rejected("intake rejected the lead (" + status + ", request_id="
                + res.headers().firstValue("X-Request-Id").orElse("") + "): " + res.body());
        }
        throw new IllegalStateException("unreachable");
    }

    // Exponential, 30 s cap, up to 500 ms of jitter so workers do not retry in lockstep.
    private static long backoffMs(int n) {
        return Math.min(30_000L, 1000L << (n - 1)) + ThreadLocalRandom.current().nextLong(500);
    }

    // Use your JSON library here; this keeps the sample dependency-free.
    private static String eventId(String body) {
        Matcher m = Pattern.compile("\"event_id\"\\s*:\\s*\"([^\"]+)\"").matcher(body);
        return m.find() ? m.group(1) : "";
    }
}

using System.Net.Http.Json;
using System.Text.Json;

public sealed class IntakeClient
{
    private const string Endpoint = "https://intake.hellojade.ai/v1/intake";
    private const int MaxAttempts = 5;
    private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(20) };

    /// <summary>A 4xx other than 429: the body needs fixing. Never retried.</summary>
    public sealed class RejectedException(string message) : Exception(message);

    /// <summary>POST one lead; returns its event_id. leadId is YOUR stable id (the Idempotency-Key).</summary>
    public static async Task<string> SendLeadAsync(object lead, string leadId, CancellationToken ct = default)
    {
        var rateWaits = 0;
        for (var attempt = 1; attempt <= MaxAttempts; attempt++)
        {
            using var req = new HttpRequestMessage(HttpMethod.Post, Endpoint);
            req.Headers.Add("X-API-Key", Environment.GetEnvironmentVariable("HELLOJADE_API_KEY"));
            req.Headers.Add("Idempotency-Key", $"acme-leads:{leadId}");            // rules 2 + 3: ours, namespaced, stable
            req.Headers.Add("X-Request-Id", $"acme-leads/{leadId}/{attempt}");
            req.Content = JsonContent.Create(lead);                                  // Content-Type: application/json

            HttpResponseMessage res;
            try
            {
                res = await Http.SendAsync(req, ct);
            }
            catch (Exception e) when (e is HttpRequestException or TaskCanceledException)
            {
                // Transport error or timeout: safe to retry, the same key cannot duplicate.
                if (attempt == MaxAttempts) throw;
                await Task.Delay(Backoff(attempt), ct);
                continue;
            }
            using (res)
            {
                var status = (int)res.StatusCode;
                var body = await res.Content.ReadAsStringAsync(ct);
                if (status is 202 or 200)                                             // accepted, or a duplicate we already had
                {
                    using var doc = JsonDocument.Parse(body);
                    return doc.RootElement.GetProperty("event_id").GetString()!;
                }
                if (status == 429)
                {
                    if (++rateWaits > 10) throw new HttpRequestException("intake: rate limited for too long");
                    var floor = res.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(1);
                    var wait = Backoff(rateWaits);
                    await Task.Delay(floor > wait ? floor : wait, ct);
                    attempt--;                                                        // a 429 does not consume an attempt
                    continue;
                }
                if (status >= 500)
                {
                    if (attempt == MaxAttempts) throw new HttpRequestException($"intake {status}");
                    await Task.Delay(Backoff(attempt), ct);
                    continue;
                }
                // Any other 4xx is our bug; keep request_id for support.
                var requestId = res.Headers.TryGetValues("X-Request-Id", out var v) ? string.Join(",", v) : "";
                throw new RejectedException($"intake rejected the lead ({status}, request_id={requestId}): {body}");
            }
        }
        throw new InvalidOperationException("unreachable");
    }

    // Exponential, 30 s cap, up to 500 ms of jitter so workers do not retry in lockstep.
    private static TimeSpan Backoff(int n) =>
        TimeSpan.FromMilliseconds(Math.Min(30_000, 1000 * Math.Pow(2, n - 1)) + Random.Shared.Next(500));
}

// Cargo.toml:
//   reqwest    = { version = "0.12", features = ["json"] }
//   tokio      = { version = "1",    features = ["full"] }
//   serde_json = "1"
//   rand       = "0.8"
use std::time::Duration;

const ENDPOINT: &str = "https://intake.hellojade.ai/v1/intake";
const MAX_ATTEMPTS: u32 = 5;

#[derive(Debug)]
pub enum IntakeError {
    Transport(reqwest::Error),
    /// A 4xx other than 429: the body needs fixing. Never retried. Keep request_id for support.
    Rejected { status: u16, request_id: String, body: String },
    Exhausted(String),
}

// Exponential, 30 s cap, up to 500 ms of jitter so workers do not retry in lockstep.
fn backoff(n: u32) -> Duration {
    let base = (1000u64 << (n - 1)).min(30_000);
    Duration::from_millis(base + rand::random::<u64>() % 500)
}

/// POST one lead; returns its event_id. lead_id is YOUR stable id (the Idempotency-Key).
pub async fn send_lead(client: &reqwest::Client, lead: &serde_json::Value, lead_id: &str)
    -> Result<String, IntakeError>
{
    let key = std::env::var("HELLOJADE_API_KEY").expect("HELLOJADE_API_KEY");
    let mut rate_waits = 0u32;
    let mut attempt = 1u32;
    while attempt <= MAX_ATTEMPTS {
        let sent = client
            .post(ENDPOINT)
            .timeout(Duration::from_secs(20))
            .header("X-API-Key", &key)
            .header("Idempotency-Key", format!("acme-leads:{lead_id}"))          // rules 2 + 3: ours, namespaced, stable
            .header("X-Request-Id", format!("acme-leads/{lead_id}/{attempt}"))
            .json(lead)                                                          // Content-Type: application/json
            .send()
            .await;
        let res = match sent {
            Ok(r) => r,
            Err(e) => {                                                          // transport error or timeout: safe to retry
                if attempt == MAX_ATTEMPTS { return Err(IntakeError::Transport(e)); }
                tokio::time::sleep(backoff(attempt)).await;
                attempt += 1;
                continue;
            }
        };
        let status = res.status().as_u16();
        let request_id = res.headers().get("x-request-id")
            .and_then(|v| v.to_str().ok()).unwrap_or("").to_string();
        let retry_after = res.headers().get("retry-after")
            .and_then(|v| v.to_str().ok()).and_then(|v| v.parse::<u64>().ok()).unwrap_or(1);
        let body = res.text().await.map_err(IntakeError::Transport)?;

        match status {
            202 | 200 => {                                                       // accepted, or a duplicate we already had
                let v: serde_json::Value = serde_json::from_str(&body)
                    .map_err(|e| IntakeError::Exhausted(e.to_string()))?;
                return Ok(v["event_id"].as_str().unwrap_or("").to_string());
            }
            429 => {
                rate_waits += 1;
                if rate_waits > 10 { return Err(IntakeError::Exhausted("rate limited for too long".into())); }
                tokio::time::sleep(Duration::from_secs(retry_after).max(backoff(rate_waits))).await;
                // a 429 does not consume an attempt
            }
            500..=599 => {
                if attempt == MAX_ATTEMPTS { return Err(IntakeError::Exhausted(format!("intake {status}"))); }
                tokio::time::sleep(backoff(attempt)).await;
                attempt += 1;
            }
            _ => return Err(IntakeError::Rejected { status, request_id, body }),
        }
    }
    Err(IntakeError::Exhausted("unreachable".into()))
}