Claude 3 API 529/503 과부하 재시도·백오프 설계

type RetryableStatus = 429 | 503 | 529;

function isRetryableStatus(status: number): status is RetryableStatus {
  return status === 429 || status === 503 || status === 529;
}

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

  // Retry-After는 초 또는 HTTP-date일 수 있음
  const asSeconds = Number(value);
  if (Number.isFinite(asSeconds)) return Math.max(0, asSeconds * 1000);

  const asDate = Date.parse(value);
  if (!Number.isNaN(asDate)) return Math.max(0, asDate - Date.now());

  return null;
}

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

function fullJitterDelayMs(baseMs: number, capMs: number, attempt: number) {
  const exp = Math.min(capMs, baseMs * 2 ** attempt);
  return Math.floor(Math.random() * exp);
}

type FetchLikeResponse = {
  ok: boolean;
  status: number;
  headers: { get(name: string): string | null };
  text(): Promise<string>;
  json(): Promise<unknown>;
};

type FetchLike = (input: string, init?: Record<string, unknown>) => Promise<FetchLikeResponse>;

export async function callWithRetry<T>(
  fetchFn: FetchLike,
  url: string,
  init: Record<string, unknown>,
  parse: (res: FetchLikeResponse) => Promise<T>,
  opts?: {
    maxAttempts?: number;
    baseDelayMs?: number;
    maxDelayMs?: number;
    totalBudgetMs?: number;
  }
): Promise<T> {
  const maxAttempts = opts?.maxAttempts ?? 6;
  const baseDelayMs = opts?.baseDelayMs ?? 400;
  const maxDelayMs = opts?.maxDelayMs ?? 10_000;
  const totalBudgetMs = opts?.totalBudgetMs ?? 60_000;

  const startedAt = Date.now();
  let lastErr: unknown;

  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
    const elapsed = Date.now() - startedAt;
    if (elapsed > totalBudgetMs) {
      throw new Error(`retry budget exceeded after ${elapsed}ms`);
    }

    try {
      const res = await fetchFn(url, init);

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

      if (!isRetryableStatus(res.status)) {
        const body = await res.text().catch(() => "");
        throw new Error(`non-retryable status=${res.status} body=${body}`);
      }

      // retryable
      const retryAfter = parseRetryAfterMs(res.headers.get("retry-after"));
      const delay = retryAfter ?? fullJitterDelayMs(baseDelayMs, maxDelayMs, attempt);

      // 마지막 시도면 종료
      if (attempt === maxAttempts) {
        const body = await res.text().catch(() => "");
        throw new Error(`retry exhausted status=${res.status} body=${body}`);
      }

      await sleep(delay);
      continue;
    } catch (e) {
      lastErr = e;

      // 네트워크 오류도 재시도하되, 마지막이면 throw
      if (attempt === maxAttempts) throw e;

      const delay = fullJitterDelayMs(baseDelayMs, maxDelayMs, attempt);
      await sleep(delay);
    }
  }

  throw lastErr instanceof Error ? lastErr : new Error("unknown error");
}

import pLimit from "p-limit";

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

async function runBatch(inputs: string[]) {
  return await Promise.all(
    inputs.map((x) =>
      limit(async () => {
        // callWithRetry로 감싼 Claude 호출
        return await doClaudeRequest(x);
      })
    )
  );
}

type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";

class SimpleCircuitBreaker {
  private state: CircuitState = "CLOSED";
  private openedAt = 0;
  private failCount = 0;
  private successCount = 0;

  constructor(
    private readonly openAfterFails: number,
    private readonly coolDownMs: number
  ) {}

  canPass() {
    if (this.state === "CLOSED") return true;

    if (this.state === "OPEN") {
      if (Date.now() - this.openedAt >= this.coolDownMs) {
        this.state = "HALF_OPEN";
        this.failCount = 0;
        this.successCount = 0;
        return true;
      }
      return false;
    }

    // HALF_OPEN: 1~소량만 허용하는 정책이 이상적이지만, 여기선 단순화
    return true;
  }

  onSuccess() {
    if (this.state === "HALF_OPEN") {
      this.successCount++;
      if (this.successCount >= 3) this.state = "CLOSED";
    }
  }

  onFailure() {
    this.failCount++;
    if (this.state === "HALF_OPEN" || this.failCount >= this.openAfterFails) {
      this.state = "OPEN";
      this.openedAt = Date.now();
    }
  }
}