Idempotency and retries

KEY=$(uuidgen)
curl https://platform.detectif.ai/v1/deepfake/detect \
  --retry 4 --retry-max-time 120 \
  -H "Authorization: Bearer $DETECTIF_API_KEY" \
  -H "Idempotency-Key: $KEY" \
  -F "file=@call-recording.wav"

import os
import random
import time
import uuid
import requests

API = "https://platform.detectif.ai/v1"
RETRYABLE = {429, 500, 502, 503, 504}

def post_with_retries(endpoint, path, fields=None, max_attempts=5):
    key = str(uuid.uuid4())  # one key for every attempt of this request
    for attempt in range(1, max_attempts + 1):
        try:
            with open(path, "rb") as f:
                resp = requests.post(
                    f"{API}/{endpoint}",
                    headers={
                        "Authorization": f"Bearer {os.environ['DETECTIF_API_KEY']}",
                        "Idempotency-Key": key,
                    },
                    data=fields or {},
                    files={"file": (os.path.basename(path), f)},
                    timeout=120,
                )
        except requests.RequestException:
            resp = None  # network error: retry with the same key
        if resp is not None:
            body = resp.json()
            if resp.ok:
                return body
            if resp.status_code not in RETRYABLE or attempt == max_attempts:
                raise RuntimeError(f"{body['error']['code']}: {body['error']['message']} ({body['request_id']})")
            retry_after = resp.headers.get("Retry-After")
            if retry_after:
                time.sleep(float(retry_after))
                continue
        if attempt == max_attempts:
            raise RuntimeError("request failed after retries")
        time.sleep(min(30, 2 ** attempt) * random.uniform(0.5, 1.0))

body = post_with_retries("deepfake/detect", "call-recording.wav")
print(body["result"]["label"], body["idempotent_replay"])

import { readFile } from "node:fs/promises";
import { basename } from "node:path";
import { randomUUID } from "node:crypto";

const API = "https://platform.detectif.ai/v1";
const RETRYABLE = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function postWithRetries(endpoint, path, fields = {}, maxAttempts = 5) {
  const key = randomUUID(); // one key for every attempt of this request
  const audio = await readFile(path);
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const form = new FormData();
    for (const [k, v] of Object.entries(fields)) form.append(k, v);
    form.append("file", new Blob([audio]), basename(path));
    let res;
    try {
      res = await fetch(`${API}/${endpoint}`, {
        method: "POST",
        headers: { Authorization: `Bearer ${process.env.DETECTIF_API_KEY}`, "Idempotency-Key": key },
        body: form,
        signal: AbortSignal.timeout(120_000),
      });
    } catch {
      res = undefined; // network error: retry with the same key
    }
    if (res) {
      const body = await res.json();
      if (res.ok) return body;
      if (!RETRYABLE.has(res.status) || attempt === maxAttempts) {
        throw new Error(`${body.error.code}: ${body.error.message} (${body.request_id})`);
      }
      const retryAfter = Number(res.headers.get("retry-after"));
      if (retryAfter > 0) {
        await sleep(retryAfter * 1000);
        continue;
      }
    }
    if (attempt === maxAttempts) throw new Error("request failed after retries");
    await sleep(Math.min(30, 2 ** attempt) * 1000 * (0.5 + Math.random() / 2));
  }
}

const body = await postWithRetries("deepfake/detect", "call-recording.wav");
console.log(body.result.label, body.idempotent_replay);

curl https://platform.detectif.ai/v1/operations/op_9a0f3b6c1e72d8e6725b71fcb5f62c89 \
  -H "Authorization: Bearer $DETECTIF_API_KEY"

import os
import time
import requests

def wait_for_operation(operation_id, timeout_s=120):
    url = f"https://platform.detectif.ai/v1/operations/{operation_id}"
    headers = {"Authorization": f"Bearer {os.environ['DETECTIF_API_KEY']}"}
    deadline = time.monotonic() + timeout_s
    while time.monotonic() < deadline:
        op = requests.get(url, headers=headers, timeout=30).json()
        if op.get("status") in ("succeeded", "failed"):
            return op
        time.sleep(2)
    raise TimeoutError(operation_id)

async function waitForOperation(operationId, timeoutMs = 120_000) {
  const url = `https://platform.detectif.ai/v1/operations/${operationId}`;
  const headers = { Authorization: `Bearer ${process.env.DETECTIF_API_KEY}` };
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const op = await (await fetch(url, { headers })).json();
    if (op.status === "succeeded" || op.status === "failed") return op;
    await new Promise((r) => setTimeout(r, 2000));
  }
  throw new Error(`timed out waiting for ${operationId}`);
}