Claude API 529·429 재시도 전략과 구현 패턴

type RetryOptions = {
  maxAttempts: number;        // 예: 6
  baseDelayMs: number;        // 예: 300
  maxDelayMs: number;         // 예: 8_000
  deadlineMs: number;         // 예: 20_000
};

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

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

function parseRetryAfterMs(headers: Headers): number | null {
  const v = headers.get("retry-after");
  if (!v) return null;

  // Retry-After can be seconds or HTTP date
  const asSeconds = Number(v);
  if (!Number.isNaN(asSeconds)) return Math.max(0, asSeconds * 1000);

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

  return null;
}

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

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

export async function withRetry<T>(
  fn: () => Promise<T>,
  opts: RetryOptions
): Promise<T> {
  const start = Date.now();
  let lastErr: unknown;

  for (let attempt = 0; attempt < opts.maxAttempts; attempt++) {
    const elapsed = Date.now() - start;
    if (elapsed > opts.deadlineMs) {
      throw new Error(`Retry deadline exceeded after ${elapsed}ms`);
    }

    try {
      return await fn();
    } catch (e: any) {
      lastErr = e;

      // If this is a fetch Response error wrapper you use, adapt here.
      const status: number | undefined = e?.status;
      const headers: Headers | undefined = e?.headers;

      if (typeof status === "number" && !isRetryableStatus(status)) {
        throw e;
      }

      // Last attempt: rethrow
      if (attempt === opts.maxAttempts - 1) {
        throw e;
      }

      // 429: honor Retry-After if present
      let delayMs: number;
      if (status === 429 && headers) {
        const ra = parseRetryAfterMs(headers);
        if (ra !== null) {
          delayMs = clamp(ra, 0, opts.maxDelayMs);
        } else {
          delayMs = computeFullJitterDelayMs(opts.baseDelayMs, attempt, opts.maxDelayMs);
        }
      } else {
        // 529 and others: exponential backoff + full jitter
        delayMs = computeFullJitterDelayMs(opts.baseDelayMs, attempt, opts.maxDelayMs);
      }

      // Keep some budget for next tries
      const remaining = opts.deadlineMs - (Date.now() - start);
      if (remaining <= 0) throw e;

      await sleep(Math.min(delayMs, remaining));
    }
  }

  throw lastErr;
}

type HttpError = Error & { status?: number; headers?: Headers };

async function callClaude(payload: any) {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-api-key": process.env.CLAUDE_API_KEY!,
      "anthropic-version": "2023-06-01",
    },
    body: JSON.stringify(payload),
  });

  if (!res.ok) {
    const err: HttpError = new Error(`Claude API error: ${res.status}`);
    err.status = res.status;
    err.headers = res.headers;
    throw err;
  }

  return res.json();
}

export async function callClaudeWithRetry(payload: any) {
  return withRetry(() => callClaude(payload), {
    maxAttempts: 6,
    baseDelayMs: 300,
    maxDelayMs: 8000,
    deadlineMs: 20000,
  });
}

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

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

  async acquire() {
    if (this.available > 0) {
      this.available -= 1;
      return;
    }

    await new Promise<void>((resolve) => this.queue.push(resolve));
    this.available -= 1;
  }

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

const claudeSem = new Semaphore(3); // 예: 동시 3개로 제한

export async function callClaudeLimited(payload: any) {
  await claudeSem.acquire();
  try {
    return await callClaudeWithRetry(payload);
  } finally {
    claudeSem.release();
  }
}

import crypto from "crypto";

function stableHash(input: any) {
  const s = JSON.stringify(input);
  return crypto.createHash("sha256").update(s).digest("hex");
}

// pseudo: get/set from Redis
async function getCached(key: string): Promise<any | null> { return null; }
async function setCached(key: string, value: any, ttlSec: number): Promise<void> { }

export async function callClaudeIdempotent(payload: any) {
  const key = `claude:msg:${stableHash(payload)}`;

  const cached = await getCached(key);
  if (cached) return cached;

  const result = await callClaudeLimited(payload);
  await setCached(key, result, 60);
  return result;
}