Errors

import os, random, time, uuid
import requests

API = "https://api.onlyx.ai/v1"
S = requests.Session()
S.headers["Authorization"] = f"Bearer {os.environ['ONLYX_API_KEY']}"
RETRYABLE = {"RATE_LIMITED", "IDEMPOTENCY_IN_PROGRESS", "SEND_UNAVAILABLE", "SENDING_DISABLED",
             "CAPACITY_UNAVAILABLE", "SERVICE_UNAVAILABLE", "MEDIA_UNAVAILABLE", "INTERNAL_ERROR"}


class OnlyXError(Exception):
    def __init__(self, status, code, message, request_id):
        super().__init__(f"{status} {code}: {message} (request {request_id})")
        self.status, self.code, self.request_id = status, code, request_id


def call(method, path, *, json=None, params=None, idempotent=False, attempts=5):
    headers = {"Idempotency-Key": str(uuid.uuid4())} if idempotent else {}
    for attempt in range(attempts):
        try:
            r = S.request(method, f"{API}{path}", json=json, params=params, headers=headers, timeout=30)
        except requests.RequestException:
            time.sleep(min(2 ** attempt, 30) + random.random())
            continue
        if r.status_code < 400:
            return r.json() if r.content else None
        try:
            err = r.json().get("error", {})
        except ValueError:  # a non-JSON answer from a network device in between
            err = {"code": "INTERNAL_ERROR" if r.status_code >= 500 else None}
        if err.get("code") in RETRYABLE and attempt < attempts - 1:
            wait = int(r.headers.get("Retry-After", 0)) or min(2 ** attempt, 30)
            time.sleep(wait + random.random())
            continue
        raise OnlyXError(r.status_code, err.get("code"), err.get("message"), err.get("requestId"))
    raise OnlyXError(0, "NETWORK", "no response after retries", None)

const API = "https://api.onlyx.ai/v1";
const RETRYABLE = new Set(["RATE_LIMITED", "IDEMPOTENCY_IN_PROGRESS", "SEND_UNAVAILABLE", "SENDING_DISABLED",
  "CAPACITY_UNAVAILABLE", "SERVICE_UNAVAILABLE", "MEDIA_UNAVAILABLE", "INTERNAL_ERROR"]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export class OnlyXError extends Error {
  constructor(status, code, message, requestId) {
    super(`${status} ${code}: ${message} (request ${requestId})`);
    Object.assign(this, { status, code, requestId });
  }
}

export async function call(method, path, { body, idempotent = false, attempts = 5 } = {}) {
  const headers = {
    Authorization: `Bearer ${process.env.ONLYX_API_KEY}`,
    ...(body ? { "Content-Type": "application/json" } : {}),
    ...(idempotent ? { "Idempotency-Key": crypto.randomUUID() } : {}), // same key on every retry
  };
  for (let attempt = 0; attempt < attempts; attempt++) {
    let res;
    try {
      res = await fetch(`${API}${path}`, { method, headers, body: body ? JSON.stringify(body) : undefined });
    } catch {
      await sleep(Math.min(2 ** attempt, 30) * 1000 + Math.random() * 1000);
      continue;
    }
    if (res.status < 400) return res.status === 204 ? null : res.json();
    const { error = {} } = await res.json().catch(() => ({}));
    if (RETRYABLE.has(error.code) && attempt < attempts - 1) {
      const wait = Number(res.headers.get("Retry-After")) || Math.min(2 ** attempt, 30);
      await sleep(wait * 1000 + Math.random() * 1000);
      continue;
    }
    throw new OnlyXError(res.status, error.code, error.message, error.requestId);
  }
  throw new OnlyXError(0, "NETWORK", "no response after retries", null);
}