OpenAI 429 RateLimitError 재시도·백오프 구현

type RetryOptions = {
  maxAttempts: number; // 전체 시도 횟수(최초 1회 포함)
  baseDelayMs: number;
  maxDelayMs: number;
  jitter: "full" | "equal" | "none";
  retryOnStatuses: number[];
  onRetry?: (info: {
    attempt: number;
    delayMs: number;
    status?: number;
    message: string;
  }) => void;
};

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

function clamp(n: number, min: number, max: number) {
  return Math.max(min, Math.min(max, n));
}

function computeBackoffMs(attemptIndex: number, opt: RetryOptions) {
  // attemptIndex: 0부터 시작(첫 재시도는 0)
  const exp = opt.baseDelayMs * Math.pow(2, attemptIndex);
  const capped = clamp(exp, 0, opt.maxDelayMs);

  if (opt.jitter === "none") return capped;

  if (opt.jitter === "full") {
    return Math.floor(Math.random() * capped);
  }

  // equal jitter
  const half = capped / 2;
  return Math.floor(half + Math.random() * half);
}

function parseRetryAfterMs(retryAfter: string | null): number | null {
  if (!retryAfter) return null;

  // 1) 초 단위 숫자
  const seconds = Number(retryAfter);
  if (!Number.isNaN(seconds) && seconds >= 0) {
    return Math.floor(seconds * 1000);
  }

  // 2) HTTP date
  const date = new Date(retryAfter);
  const diff = date.getTime() - Date.now();
  if (!Number.isNaN(date.getTime()) && diff > 0) {
    return diff;
  }

  return null;
}

export async function withRetry<T>(
  fn: () => Promise<T>,
  opt: RetryOptions
): Promise<T> {
  let lastErr: unknown;

  for (let attempt = 1; attempt <= opt.maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      lastErr = err;

      const status: number | undefined =
        err?.status ?? err?.response?.status ?? err?.cause?.status;

      const message =
        err?.message ?? err?.error?.message ?? "request failed";

      const shouldRetry =
        typeof status === "number" && opt.retryOnStatuses.includes(status);

      const isLast = attempt === opt.maxAttempts;
      if (!shouldRetry || isLast) {
        throw err;
      }

      const retryAfterHeader: string | null =
        err?.response?.headers?.get?.("retry-after") ??
        err?.headers?.get?.("retry-after") ??
        null;

      const retryAfterMs = parseRetryAfterMs(retryAfterHeader);
      const backoffMs = computeBackoffMs(attempt - 1, opt);
      const delayMs = retryAfterMs ?? backoffMs;

      opt.onRetry?.({
        attempt,
        delayMs,
        status,
        message,
      });

      await sleep(delayMs);
    }
  }

  throw lastErr;
}

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

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

export async function generateSummary(input: string) {
  return withRetry(
    async () => {
      const res = await client.responses.create({
        model: "gpt-4.1-mini",
        input,
      });
      return res;
    },
    {
      maxAttempts: 6,
      baseDelayMs: 250,
      maxDelayMs: 10_000,
      jitter: "full",
      retryOnStatuses: [429, 500, 502, 503, 504],
      onRetry: ({ attempt, delayMs, status, message }) => {
        console.warn(
          JSON.stringify({
            msg: "openai retry",
            attempt,
            delayMs,
            status,
            message,
          })
        );
      },
    }
  );
}

import pLimit from "p-limit";
import OpenAI from "openai";
import { withRetry } from "./withRetry";

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

const limit = pLimit(5); // 동시에 5개만 OpenAI 호출

export function limitedResponseCreate(params: any) {
  return limit(() =>
    withRetry(
      () => client.responses.create(params),
      {
        maxAttempts: 6,
        baseDelayMs: 250,
        maxDelayMs: 10_000,
        jitter: "full",
        retryOnStatuses: [429, 500, 502, 503, 504],
      }
    )
  );
}

// 예: 배치 처리
export async function runBatch(inputs: string[]) {
  const tasks = inputs.map((input) =>
    limitedResponseCreate({ model: "gpt-4.1-mini", input })
  );
  return Promise.all(tasks);
}