Idempotency

async function postWithRetry(path: string, body: unknown, key = crypto.randomUUID()) {
  const deadline = Date.now() + 300_000;
  for (let attempt = 0; attempt < 5; attempt++) {
    let res: Response;
    try {
      res = await fetch(`https://app.reflections.ai/v1${path}`, {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.REFLECTIONS_KEY}`,
          "Reflections-Version": "2026-10-15",
          "Idempotency-Key": key,
          "Content-Type": "application/json",
        },
        body: JSON.stringify(body),
        signal: AbortSignal.timeout(10_000),
      });
    } catch {
      await sleep(backoff(attempt));
      continue; // Unknown outcome: retry with the same key.
    }
    if (res.ok) {
      const result = await res.json();
      // A live check still evaluating is not final: send the same body and key after Retry-After.
      if (res.status === 202 && result.object === "check" && result.status === "checking") {
        if (Date.now() > deadline) throw new Error("The check is still evaluating: do not generate a named talent");
        await sleep(retryAfterMs(res) ?? 1000);
        attempt--; // Waiting for a decision does not use up a retry.
        continue;
      }
      return result;
    }
    const problem = await res.json().catch(() => ({})); // a proxy's 502 may not be JSON
    const retryable =
      res.status === 429 || res.status >= 500 || problem.code === "idempotency_key_in_use";
    if (!retryable) throw new Error(`${res.status} ${problem.code}: ${problem.detail ?? problem.title}`);
    await sleep(retryAfterMs(res) ?? backoff(attempt));
  }
  throw new Error("Reflections unavailable: do not generate a named talent");
}

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
const backoff = (attempt: number) => Math.min(250 * 2 ** attempt, 4000) * (0.5 + Math.random());

// Retry-After from Reflections is in seconds; a proxy in front of it may send an HTTP date.
function retryAfterMs(res: Response): number | undefined {
  const value = res.headers.get("Retry-After");
  if (!value) return undefined;
  const seconds = Number(value);
  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
  const date = Date.parse(value);
  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
}

import os, random, time, uuid, requests
from email.utils import parsedate_to_datetime

def post_with_retry(path, body, key=None):
    key = key or str(uuid.uuid4())
    deadline = time.monotonic() + 300
    attempt = 0
    while attempt < 5:
        try:
            res = requests.post(
                f"https://app.reflections.ai/v1{path}",
                headers={
                    "Authorization": f"Bearer {os.environ['REFLECTIONS_KEY']}",
                    "Reflections-Version": "2026-10-15",
                    "Idempotency-Key": key,
                },
                json=body,
                timeout=10,
            )
        except requests.RequestException:
            time.sleep(backoff(attempt))
            attempt += 1
            continue  # Unknown outcome: retry with the same key.
        if res.ok:
            result = res.json()
            # A live check still evaluating is not final: send the same body and key after Retry-After.
            if res.status_code == 202 and result.get("object") == "check" and result.get("status") == "checking":
                if time.monotonic() > deadline:
                    raise RuntimeError("The check is still evaluating: do not generate a named talent")
                wait = retry_after(res)
                time.sleep(1 if wait is None else wait)
                continue  # Waiting for a decision does not use up a retry.
            return result
        try:
            problem = res.json()
        except ValueError:  # a proxy's 502 may not be JSON
            problem = {}
        retryable = res.status_code == 429 or res.status_code >= 500 or problem.get("code") == "idempotency_key_in_use"
        if not retryable:
            raise RuntimeError(f"{res.status_code} {problem.get('code')}: {problem.get('detail', problem.get('title'))}")
        wait = retry_after(res)
        time.sleep(backoff(attempt) if wait is None else wait)
        attempt += 1
    raise RuntimeError("Reflections unavailable: do not generate a named talent")

def backoff(attempt):
    return min(0.25 * 2 ** attempt, 4) * (0.5 + random.random())

def retry_after(res):
    """Seconds to wait, or None. Reflections sends seconds; a proxy may send an HTTP date."""
    value = res.headers.get("Retry-After")
    if not value:
        return None
    try:
        return max(0.0, float(value))
    except ValueError:
        pass
    try:
        return max(0.0, parsedate_to_datetime(value).timestamp() - time.time())
    except (TypeError, ValueError):
        return None