Errors and retries

import { randomUUID } from "node:crypto";

const RETRYABLE = new Set([429, 500, 502, 503, 504]);
const MAX_WAIT_MS = 60_000;

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

async function leapRequest(path: string, init: RequestInit = {}, attempts = 5) {
  for (let attempt = 1; ; attempt++) {
    // Exponential backoff with full jitter: up to 1 s, 2 s, 4 s and so on.
    let waitMs = Math.random() * Math.min(MAX_WAIT_MS, 1_000 * 2 ** (attempt - 1));
    let response: Response | undefined;

    try {
      response = await fetch(`https://api.tryleap.ai${path}`, {
        ...init,
        headers: { "x-api-key": process.env.LEAP_API_KEY ?? "", ...init.headers },
        signal: AbortSignal.timeout(90_000),
      });
    } catch (error) {
      // The connection dropped or the request timed out.
      if (attempt >= attempts) throw error;
    }

    if (response) {
      const retryAfter = Number(response.headers.get("retry-after"));
      if (retryAfter > 0) waitMs = retryAfter * 1_000;

      if (!RETRYABLE.has(response.status) || attempt >= attempts || waitMs > MAX_WAIT_MS) {
        const text = await response.text();
        let body;
        try {
          body = JSON.parse(text);
        } catch {
          // Not JSON, such as a proxy's HTML error page.
        }

        if (response.ok) return body;
        throw new Error(body?.error ? `${body.error.code}: ${body.error.message}` : `HTTP ${response.status}`);
      }
    }

    await sleep(waitMs);
  }
}

// One key per new run, sent again with every retry of it.
const generation = await leapRequest("/v1/generations", {
  method: "POST",
  headers: { "content-type": "application/json", "idempotency-key": randomUUID() },
  body: JSON.stringify({
    model: "black-forest-labs/flux-2-pro",
    input: { prompt: "A fox in the snow, watercolor" },
  }),
});

import os
import random
import time
import uuid

import requests

RETRYABLE = {429, 500, 502, 503, 504}
MAX_WAIT = 60


def leap_request(method, path, attempts=5, **kwargs):
    headers = {"x-api-key": os.environ["LEAP_API_KEY"], **kwargs.pop("headers", {})}
    kwargs.setdefault("timeout", 90)

    for attempt in range(1, attempts + 1):
        # Exponential backoff with full jitter: up to 1 s, 2 s, 4 s and so on.
        wait = random.uniform(0, min(MAX_WAIT, 2 ** (attempt - 1)))
        try:
            response = requests.request(
                method, f"https://api.tryleap.ai{path}", headers=headers, **kwargs
            )
        except requests.RequestException:
            # The connection dropped or the request timed out.
            if attempt == attempts:
                raise
            time.sleep(wait)
            continue

        retry_after = response.headers.get("retry-after", "")
        if retry_after.isdigit():
            wait = int(retry_after)

        if response.status_code in RETRYABLE and attempt < attempts and wait <= MAX_WAIT:
            time.sleep(wait)
            continue

        try:
            body = response.json()
        except ValueError:
            # Not JSON, such as a proxy's HTML error page.
            body = None

        if response.ok:
            return body
        if isinstance(body, dict) and "error" in body:
            raise RuntimeError(f"{body['error']['code']}: {body['error']['message']}")
        raise RuntimeError(f"HTTP {response.status_code}")


# One key per new run, sent again with every retry of it.
generation = leap_request(
    "POST",
    "/v1/generations",
    headers={"idempotency-key": str(uuid.uuid4())},
    json={
        "model": "black-forest-labs/flux-2-pro",
        "input": {"prompt": "A fox in the snow, watercolor"},
    },
)