Retry requests safely

curl "https://api.echonova.ai/v1/text-to-speech/jobs?limit=20" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.data.items[] | {id, status, text, createdAt}'

import requests

items = requests.get(
    "https://api.echonova.ai/v1/text-to-speech/jobs",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    params={"limit": 20},
).json()["data"]["items"]

# TEXT is the text you sent. SENT_AT is the ISO 8601 UTC time you recorded
# just before the POST.
lost = next(
    (job for job in items if job["text"] == TEXT and job["createdAt"] >= SENT_AT),
    None,
)
if lost:
    job_id = lost["id"]  # resume polling with this id; do not POST again

const response = await fetch('https://api.echonova.ai/v1/text-to-speech/jobs?limit=20', {
  headers: { Authorization: 'Bearer YOUR_API_KEY' },
});
const { data } = await response.json();

// TEXT is the text you sent. SENT_AT is the ISO 8601 UTC time you recorded
// just before the POST.
const lost = data.items.find((job) => job.text === TEXT && job.createdAt >= SENT_AT);
if (lost) {
  const jobId = lost.id; // resume polling with this id; do not POST again
}

BASE_URL="https://api.echonova.ai"
AUTH="Authorization: Bearer YOUR_API_KEY"

# Exactly one POST. Save the job id before anything else.
RESPONSE=$(curl -s -X POST "$BASE_URL/v1/text-to-speech" -H "$AUTH" \
  -H "Content-Type: application/json" \
  -d '{"text": "مرحبا بكم في إيكونوڤا", "voiceId": "VOICE_ID"}')
if [ "$(echo "$RESPONSE" | jq -r '.success')" != "true" ]; then
  echo "error: $(echo "$RESPONSE" | jq -r '.errorMessage')"; exit 1
fi
echo "$RESPONSE" | jq -r '.data.jobId' > job-id.txt
JOB_ID=$(cat job-id.txt)

# Poll with GET only. 429: wait Retry-After. 5xx or no response: back off. Other 4xx: stop.
DEADLINE=$(( $(date +%s) + 900 ))
TRANSIENT=0
while [ "$(date +%s)" -lt "$DEADLINE" ]; do
  CODE=$(curl -s -o job.json -D headers.txt -w '%{http_code}' \
    "$BASE_URL/v1/text-to-speech/jobs/$JOB_ID" -H "$AUTH")
  if [ "$CODE" = "200" ]; then
    TRANSIENT=0
    STATUS=$(jq -r '.data.status' job.json)
    echo "$STATUS"
    if [ "$STATUS" = "completed" ] || [ "$STATUS" = "failed" ]; then break; fi
    sleep 3
  elif [ "$CODE" = "429" ]; then
    WAIT=$(sed -n 's/^[Rr]etry-[Aa]fter: *\([0-9]*\).*/\1/p' headers.txt)
    sleep "${WAIT:-60}"
  elif [ "$CODE" = "000" ] || [ "$CODE" -ge 500 ]; then
    TRANSIENT=$((TRANSIENT + 1))
    if [ "$TRANSIENT" -gt 5 ]; then echo "API unreachable"; exit 1; fi
    sleep $((2 ** (TRANSIENT - 1)))
  else
    echo "error: $(jq -r '.errorMessage' job.json)"; exit 1
  fi
done
jq '.data' job.json

import random
import time
import requests

BASE_URL = "https://api.echonova.ai"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}
POLL_SECONDS = 3           # recommendation, not a server value
GIVE_UP_SECONDS = 15 * 60  # a silent job is marked failed within this time
MAX_TRANSIENT = 5          # recommendation


def start_tts_job(text, voice_id):
    # Exactly one POST. If this raises before a response arrives, do not call
    # it again blindly: check the job list first (Step 4).
    response = requests.post(
        f"{BASE_URL}/v1/text-to-speech",
        headers=HEADERS,
        json={"text": text, "voiceId": voice_id},
        timeout=30,
    )
    body = response.json()
    if not body["success"]:
        raise RuntimeError(f'{body["statusCode"]}: {body["errorMessage"]}')
    job_id = body["data"]["jobId"]
    with open("job-id.txt", "w") as f:  # persist before anything else
        f.write(job_id)
    return job_id


def wait_for_job(job_id):
    deadline = time.monotonic() + GIVE_UP_SECONDS
    transient = 0
    while time.monotonic() < deadline:
        try:
            response = requests.get(
                f"{BASE_URL}/v1/text-to-speech/jobs/{job_id}",
                headers=HEADERS,
                timeout=30,
            )
        except requests.RequestException:
            response = None

        if response is not None and response.status_code == 200:
            transient = 0
            job = response.json()["data"]
            if job["status"] in ("completed", "failed"):
                return job
            time.sleep(POLL_SECONDS)
        elif response is not None and response.status_code == 429:
            # Rate limit. Wait exactly what the server asks; a sooner call is rejected.
            time.sleep(int(response.headers.get("Retry-After", "60")))
        elif response is None or response.status_code >= 500:
            transient += 1
            if transient > MAX_TRANSIENT:
                raise RuntimeError("API unreachable")
            time.sleep(2 ** (transient - 1) + random.random())
        else:
            # 400, 401, 403, 404: a retry returns the same answer. Fix the request.
            body = response.json()
            raise RuntimeError(f'{body["statusCode"]}: {body["errorMessage"]}')
    raise TimeoutError(f"job {job_id} still running after {GIVE_UP_SECONDS} s")


job_id = start_tts_job("مرحبا بكم في إيكونوڤا", "VOICE_ID")
job = wait_for_job(job_id)
print(job["status"], job.get("audioUrl") or job.get("error"))

import { writeFile } from 'node:fs/promises';

const BASE_URL = 'https://api.echonova.ai';
const HEADERS = { Authorization: 'Bearer YOUR_API_KEY' };
const POLL_MS = 3000; // recommendation, not a server value
const GIVE_UP_MS = 15 * 60 * 1000; // a silent job is marked failed within this time
const MAX_TRANSIENT = 5; // recommendation
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function startTtsJob(text, voiceId) {
  // Exactly one POST. If this throws before a response arrives, do not call
  // it again blindly: check the job list first (Step 4).
  const response = await fetch(`${BASE_URL}/v1/text-to-speech`, {
    method: 'POST',
    headers: { ...HEADERS, 'Content-Type': 'application/json' },
    body: JSON.stringify({ text, voiceId }),
  });
  const body = await response.json();
  if (!body.success) throw new Error(`${body.statusCode}: ${body.errorMessage}`);
  await writeFile('job-id.txt', body.data.jobId); // persist before anything else
  return body.data.jobId;
}

async function waitForJob(jobId) {
  const deadline = Date.now() + GIVE_UP_MS;
  let transient = 0;
  while (Date.now() < deadline) {
    let response = null;
    try {
      response = await fetch(`${BASE_URL}/v1/text-to-speech/jobs/${jobId}`, { headers: HEADERS });
    } catch {
      // connection error: handled like a 5xx below
    }

    if (response?.status === 200) {
      transient = 0;
      const { data: job } = await response.json();
      if (job.status === 'completed' || job.status === 'failed') return job;
      await sleep(POLL_MS);
    } else if (response?.status === 429) {
      // Rate limit. Wait exactly what the server asks; a sooner call is rejected.
      await sleep(Number(response.headers.get('Retry-After') ?? 60) * 1000);
    } else if (response === null || response.status >= 500) {
      transient += 1;
      if (transient > MAX_TRANSIENT) throw new Error('API unreachable');
      await sleep((2 ** (transient - 1) + Math.random()) * 1000);
    } else {
      // 400, 401, 403, 404: a retry returns the same answer. Fix the request.
      const body = await response.json();
      throw new Error(`${body.statusCode}: ${body.errorMessage}`);
    }
  }
  throw new Error(`job ${jobId} still running after ${GIVE_UP_MS / 1000} s`);
}

const jobId = await startTtsJob('مرحبا بكم في إيكونوڤا', 'VOICE_ID');
const job = await waitForJob(jobId);
console.log(job.status, job.audioUrl ?? job.error);