Errors

{
  "error": {
    "type": "insufficient_credits",
    "message": "insufficient credit balance — add credits to create sandboxes"
  },
  "request_id": "a2f1c0de-6b1a-4a0e-9c2f-2f4d0f0a1b23"
}

import os
import random
import time
import requests

API = "https://sandbox-as-a-service.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['AAS_API_KEY']}"}

RETRYABLE = {429, 500, 502, 503}
FATAL_TYPES = {"account_suspended", "quota_exceeded", "insufficient_credits"}


class ApiError(RuntimeError):
    def __init__(self, status, type_, message, request_id):
        super().__init__(f"{status} {type_}: {message} (request_id={request_id})")
        self.status, self.type, self.request_id = status, type_, request_id


def call(method, path, *, headers=None, attempts=5, **kwargs):
    for attempt in range(attempts):
        r = requests.request(method, f"{API}{path}",
                             headers={**HEADERS, **(headers or {})}, **kwargs)
        if r.ok:
            return r.json()

        body = r.json() if r.headers.get("content-type", "").startswith("application/json") else {}
        err = body.get("error", {})
        etype = err.get("type", "unknown")

        # Fatal regardless of status: retrying cannot make these succeed.
        if etype in FATAL_TYPES or r.status_code not in RETRYABLE:
            raise ApiError(r.status_code, etype, err.get("message", r.text), body.get("request_id"))

        delay = float(r.headers.get("Retry-After", 0)) or min(2 ** attempt, 30)
        time.sleep(delay + random.random())

    raise ApiError(r.status_code, "retries_exhausted", "gave up after retries", body.get("request_id"))

const API = "https://sandbox-as-a-service.com/v1";
const RETRYABLE = new Set([429, 500, 502, 503]);
const FATAL_TYPES = new Set(["account_suspended", "quota_exceeded", "insufficient_credits"]);

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function call(method, path, { body, headers = {}, attempts = 5 } = {}) {
  let last;
  for (let attempt = 0; attempt < attempts; attempt++) {
    const res = await fetch(`${API}${path}`, {
      method,
      headers: {
        Authorization: `Bearer ${process.env.AAS_API_KEY}`,
        "Content-Type": "application/json",
        ...headers,
      },
      body: body === undefined ? undefined : JSON.stringify(body),
    });

    if (res.ok) return res.json();

    last = await res.json().catch(() => ({}));
    const type = last?.error?.type ?? "unknown";

    if (FATAL_TYPES.has(type) || !RETRYABLE.has(res.status)) {
      const e = new Error(`${res.status} ${type}: ${last?.error?.message ?? ""}`);
      e.status = res.status;
      e.type = type;
      e.requestId = last?.request_id;
      throw e;
    }

    const retryAfter = Number(res.headers.get("Retry-After")) || Math.min(2 ** attempt, 30);
    await sleep(retryAfter * 1000 + Math.random() * 1000);
  }
  throw new Error(`gave up after retries (request_id=${last?.request_id})`);
}