OpenAI 429/RateLimitError 실전 백오프·리트라이

type RetryOptions = {
  maxRetries: number;
  baseDelayMs: number;
  maxDelayMs: number;
  maxTotalDelayMs: number;
};

function sleep(ms: number) {
  return new Promise((r) => setTimeout(r, ms));
}

function parseRetryAfterMs(headers: Headers | Record<string, string> | undefined): number | null {
  if (!headers) return null;

  const get = (k: string) => {
    if (typeof (headers as any).get === "function") return (headers as any).get(k);
    const obj = headers as Record<string, string>;
    const key = Object.keys(obj).find((x) => x.toLowerCase() === k.toLowerCase());
    return key ? obj[key] : undefined;
  };

  const v = get("retry-after");
  if (!v) return null;

  // 1) seconds
  const sec = Number(v);
  if (Number.isFinite(sec)) return Math.max(0, Math.floor(sec * 1000));

  // 2) HTTP date
  const dt = Date.parse(v);
  if (!Number.isNaN(dt)) return Math.max(0, dt - Date.now());

  return null;
}

function isRetryableStatus(status: number) {
  if (status === 429) return true;
  if (status === 408) return true;
  if (status >= 500 && status <= 599) return true;
  return false;
}

function computeFullJitterDelayMs(baseDelayMs: number, maxDelayMs: number, attempt: number) {
  const cap = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt));
  return Math.floor(Math.random() * cap);
}

export async function withRetry<T>(
  fn: () => Promise<T>,
  opts: RetryOptions,
  onRetry?: (info: { attempt: number; delayMs: number; reason: string }) => void
): Promise<T> {
  const startedAt = Date.now();

  for (let attempt = 0; ; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      const status: number | undefined = err?.status ?? err?.response?.status;
      const headers = err?.headers ?? err?.response?.headers;

      const retryAfterMs = parseRetryAfterMs(headers);
      const retryable = typeof status === "number" ? isRetryableStatus(status) : false;

      if (!retryable) throw err;
      if (attempt >= opts.maxRetries) throw err;

      const computed = computeFullJitterDelayMs(opts.baseDelayMs, opts.maxDelayMs, attempt);
      const delayMs = retryAfterMs !== null ? Math.min(opts.maxDelayMs, retryAfterMs) : computed;

      const elapsed = Date.now() - startedAt;
      if (elapsed + delayMs > opts.maxTotalDelayMs) throw err;

      onRetry?.({
        attempt,
        delayMs,
        reason: `status=${status}${retryAfterMs !== null ? ", retry-after" : ""}`,
      });

      await sleep(delayMs);
    }
  }
}

import OpenAI from "openai";
import { withRetry } from "./withRetry";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

async function run() {
  const res = await withRetry(
    async () => {
      return await client.responses.create({
        model: "gpt-4.1-mini",
        input: "요약해줘: ...",
        max_output_tokens: 400,
      });
    },
    {
      maxRetries: 6,
      baseDelayMs: 200,
      maxDelayMs: 8000,
      maxTotalDelayMs: 20000,
    },
    ({ attempt, delayMs, reason }) => {
      console.warn("retry", { attempt, delayMs, reason });
    }
  );

  console.log(res.output_text);
}

run().catch(console.error);

class Semaphore {
  private available: number;
  private queue: Array<() => void> = [];

  constructor(count: number) {
    this.available = count;
  }

  async acquire() {
    if (this.available > 0) {
      this.available -= 1;
      return;
    }
    await new Promise<void>((resolve) => this.queue.push(resolve));
  }

  release() {
    this.available += 1;
    const next = this.queue.shift();
    if (next) {
      this.available -= 1;
      next();
    }
  }
}

const sem = new Semaphore(8);

export async function limited<T>(fn: () => Promise<T>) {
  await sem.acquire();
  try {
    return await fn();
  } finally {
    sem.release();
  }
}

const res = await limited(() => withRetry(() => client.responses.create({
  model: "gpt-4.1-mini",
  input: "...",
}), {
  maxRetries: 6,
  baseDelayMs: 200,
  maxDelayMs: 8000,
  maxTotalDelayMs: 20000,
}));