OpenAI 429·insufficient_quota 재시도와 백오프 설계

import random
import time
from typing import Optional

from openai import OpenAI

client = OpenAI()


def _parse_retry_after(headers: dict) -> Optional[float]:
    # headers는 라이브러리/버전에 따라 형태가 다를 수 있음
    # 가능한 경우에만 파싱
    if not headers:
        return None
    ra = headers.get("retry-after") or headers.get("Retry-After")
    if not ra:
        return None
    try:
        return float(ra)
    except ValueError:
        return None


def call_openai_with_retry(prompt: str, *, max_attempts: int = 6,
                           base_delay: float = 0.5, max_delay: float = 20.0):
    last_exc = None

    for attempt in range(max_attempts):
        try:
            return client.responses.create(
                model="gpt-4.1-mini",
                input=prompt,
            )

        except Exception as e:
            last_exc = e

            # openai SDK 예외 구조는 버전에 따라 달라질 수 있어
            # 아래는 "정책" 중심의 방어적 분기 예시
            status = getattr(e, "status_code", None) or getattr(e, "status", None)
            err = getattr(e, "error", None)
            code = None
            msg = str(e)

            # 가능한 경우 code 추출(예: err.code)
            if err is not None:
                code = getattr(err, "code", None) or getattr(err, "type", None)

            # 1) 쿼터 소진: 재시도 금지
            if code == "insufficient_quota" or "insufficient_quota" in msg:
                raise RuntimeError(
                    "OpenAI quota exhausted (insufficient_quota). "
                    "Do not retry; check billing/limits and alert ops."
                ) from e

            # 2) 400/401/403 등은 보통 재시도해도 안 됨
            if status in (400, 401, 403):
                raise

            # 3) 429 및 5xx/네트워크 계열은 재시도
            retryable = (status == 429) or (status in (500, 502, 503, 504)) or (status is None)
            if not retryable:
                raise

            # Retry-After 우선
            headers = getattr(e, "headers", None)
            retry_after = _parse_retry_after(headers or {})

            if attempt == max_attempts - 1:
                break

            if retry_after is not None:
                sleep_s = min(retry_after, max_delay)
            else:
                exp = base_delay * (2 ** attempt)
                capped = min(exp, max_delay)
                # full jitter
                sleep_s = random.uniform(0, capped)

            time.sleep(sleep_s)

    raise RuntimeError(f"OpenAI call failed after {max_attempts} attempts") from last_exc

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

function parseRetryAfter(res) {
  const ra = res.headers.get('retry-after');
  if (!ra) return null;
  const sec = Number(ra);
  return Number.isFinite(sec) ? sec * 1000 : null;
}

export async function callOpenAIWithRetry({ url, apiKey, body, maxAttempts = 6 }) {
  const baseDelay = 500;
  const maxDelay = 20_000;

  let lastErr;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      const res = await fetch(url, {
        method: 'POST',
        headers: {
          'content-type': 'application/json',
          'authorization': `Bearer ${apiKey}`,
        },
        body: JSON.stringify(body),
      });

      if (res.ok) return await res.json();

      const text = await res.text();

      // insufficient_quota는 보통 JSON 에러 본문에 포함되므로 텍스트 검색도 방어적으로
      if (text.includes('insufficient_quota')) {
        throw new Error('insufficient_quota');
      }

      if ([400, 401, 403].includes(res.status)) {
        throw new Error(`non-retryable ${res.status}: ${text}`);
      }

      const retryable = res.status === 429 || [500, 502, 503, 504].includes(res.status);
      if (!retryable) {
        throw new Error(`unexpected ${res.status}: ${text}`);
      }

      if (attempt === maxAttempts - 1) {
        throw new Error(`failed after retries: ${res.status}: ${text}`);
      }

      const raMs = parseRetryAfter(res);
      let delay;
      if (raMs != null) {
        delay = Math.min(raMs, maxDelay);
      } else {
        const exp = Math.min(baseDelay * (2 ** attempt), maxDelay);
        delay = Math.floor(Math.random() * exp); // full jitter
      }

      await sleep(delay);

    } catch (e) {
      lastErr = e;
      if (String(e.message).includes('insufficient_quota')) {
        // 재시도 금지
        throw e;
      }
      // 네트워크 에러는 여기로 올 수 있으니 재시도 루프 지속
      if (attempt === maxAttempts - 1) throw lastErr;
    }
  }

  throw lastErr;
}