Retry and error handling

import {
  ReaderClient,
  InsufficientCreditsError,
  RateLimitedError,
  ScrapeTimeoutError,
} from "@vakra-dev/reader-js";

const reader = new ReaderClient({
  apiKey: process.env.READER_KEY!,
  maxRetries: 3, // default is 2
});

try {
  const result = await reader.read({ url });
  // handle result
} catch (err) {
  if (err instanceof InsufficientCreditsError) {
    console.error(`Need ${err.required}, have ${err.available}`);
    // Pause the worker, alert ops
  } else if (err instanceof RateLimitedError) {
    // SDK already retried. If we still got here, we exhausted retries
    console.error(`Give up after rate limit, retry in ${err.retryAfterSeconds}s`);
  } else if (err instanceof ScrapeTimeoutError) {
    // Bump timeout and try once more manually
    await reader.read({ url, timeoutMs: 60_000 });
  } else {
    throw err; // unknown, re-raise
  }
}

const TRANSIENT_CODES = new Set([
  "rate_limited",
  "concurrency_limited",
  "internal_error",
  "upstream_unavailable",
  "scrape_timeout",
]);

async function readWithRetry(body, maxAttempts = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const res = await fetch("https://api.reader.dev/v1/read", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": process.env.READER_KEY,
      },
      body: JSON.stringify(body),
    });

    const envelope = await res.json();
    if (envelope.success) return envelope.data;

    const code = envelope.error.code;
    lastError = envelope.error;

    // Permanent? Give up.
    if (!TRANSIENT_CODES.has(code)) throw new Error(envelope.error.message);

    // Rate-limited? Honor the server's hint.
    if (code === "rate_limited") {
      const retryAfter =
        parseInt(res.headers.get("Retry-After") || "") ||
        envelope.error.details?.retryAfterSeconds ||
        5;
      await sleep(retryAfter * 1000);
      continue;
    }

    // Otherwise exponential backoff: 1s, 2s, 4s
    await sleep(Math.pow(2, attempt) * 1000);
  }

  throw new Error(`Exhausted retries: ${lastError?.message}`);
}

delay = base * 2^attempt + random(0, jitter)

console.error({
  code: err.code,
  message: err.message,
  details: err.details,
  docsUrl: err.docsUrl,
  requestId: err.requestId,
  url: body.url,
});