Which HTTP errors should be retried?

import { createRatchet, RetryableError, NonRetryableError } from '@getratchet/sdk';

class ProviderFailure extends Error {
  constructor(readonly status: number, readonly retryAfter: string | null) {
    super('Provider request failed'); // no response body or credentials
  }
}
function providerDelay(value: string | null): number | undefined {
  if (!value) return undefined;
  const raw = value.trim();
  const ms = /^\d+$/.test(raw)
    ? Number(raw) * 1000 : Date.parse(raw) - Date.now();
  return Number.isFinite(ms) ? Math.max(1000, Math.ceil(ms)) : undefined;
}
const worker = createRatchet({
  baseUrl: 'https://getratchet.app',
  apiKey: process.env.GETRATCHET_WORKER_KEY!,
});
worker.registerTool({
  name: 'check_provider', version: '1',
  async handler(_input, context) {
    const response = await fetch(process.env.PROVIDER_HEALTH_URL!, {
      signal: context.signal,
    });
    if (!response.ok) {
      throw new ProviderFailure(response.status, response.headers.get('Retry-After'));
    }
    return { available: true };
  },
  classifyError(error) {
    if (error instanceof ProviderFailure) {
      if ([400, 401, 403].includes(error.status)) return { retryable: false };
      if (error.status === 429 || error.status === 503) {
        const retryAfterMs = providerDelay(error.retryAfter);
        if (retryAfterMs !== undefined && retryAfterMs > 86_400_000) {
          return { retryable: false }; // operator review, no premature retry
        }
        return { retryable: true, retryAfterMs };
      }
    }
    return { retryable: true };
  },
});
await worker.worker.start({ concurrency: 2 });

// In a handler you can instead throw either public SDK error directly:
// throw new RetryableError('Provider busy', { retryAfterMs: 60_000 });
// throw new NonRetryableError('Input needs correction');

import math
import os
import time
from email.utils import parsedate_to_datetime
from urllib.error import HTTPError
from urllib.request import urlopen
from getratchet import Ratchet, RetryableError, NonRetryableError

def provider_delay(value):
    if not value:
        return None
    raw = value.strip()
    try:
        seconds = (int(raw) if raw.isascii() and raw.isdigit()
                   else parsedate_to_datetime(raw).timestamp() - time.time())
        return max(1000, math.ceil(seconds * 1000)) if math.isfinite(seconds) else None
    except (ValueError, TypeError, OverflowError):
        return None

def classify(error, context):
    if isinstance(error, HTTPError):
        if error.code in (400, 401, 403):
            return {"retryable": False}
        if error.code in (429, 503):
            delay = provider_delay(error.headers.get("Retry-After"))
            if delay is not None and delay > 86400000:
                return {"retryable": False}
            return {"retryable": True, **({"retry_after_ms": delay} if delay is not None else {})}
    return {"retryable": True}

def check_provider(input, context):
    context.check_cancelled()
    with urlopen(os.environ["PROVIDER_HEALTH_URL"], timeout=10) as response:
        return {"available": response.status == 200}

worker = Ratchet("https://getratchet.app", os.environ["GETRATCHET_WORKER_KEY"])
worker.register_tool("check_provider", "1", check_provider, classify_error=classify)
worker.worker.start(concurrency=2)

# A handler can also raise these directly:
# raise RetryableError("Provider busy", retry_after_ms=60000)
# raise NonRetryableError("Input needs correction")