OpenAI APIの429エラーを直す方法｜Rate Limit・Retry-After・指数バックオフを実装

import OpenAI from "openai";

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

async function generateText(): Promise<string> {
  const model = process.env.OPENAI_MODEL;

  if (!model) {
    throw new Error("OPENAI_MODELが設定されていません。");
  }

  try {
    const response = await client.responses.create({
      model,
      input: "TypeScriptの型ガードについて説明してください。",
    });

    return response.output_text;
  } catch (error) {
    if (error instanceof OpenAI.APIError) {
      console.error({
        status: error.status,
        code: error.code,
        type: error.type,
        requestId: error.request_id,
        message: error.message,
        headers: error.headers,
      });
    }

    throw error;
  }
}

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  maxRetries: 5,
  timeout: 60_000,
});

const response = await client.responses.create(
  {
    model: process.env.OPENAI_MODEL!,
    input: "指数バックオフについて説明してください。",
  },
  {
    maxRetries: 5,
    timeout: 60_000,
  },
);

Retry-After: 56

import OpenAI from "openai";

const model = process.env.OPENAI_MODEL;

if (!model) {
  throw new Error("OPENAI_MODELが設定されていません。");
}

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  maxRetries: 0,
  timeout: 60_000,
});

const MAX_RETRIES = 5;
const BASE_DELAY_MS = 1_000;
const MAX_DELAY_MS = 30_000;
const JITTER_MS = 500;

const sleep = (milliseconds: number): Promise<void> =>
  new Promise((resolve) => setTimeout(resolve, milliseconds));

function readHeader(headers: unknown, name: string): string | null {
  if (!headers || typeof headers !== "object") {
    return null;
  }

  const headersObject = headers as {
    get?: (headerName: string) => string | null;
  };

  if (typeof headersObject.get === "function") {
    return headersObject.get(name);
  }

  for (const [key, value] of Object.entries(
    headers as Record<string, unknown>,
  )) {
    if (
      key.toLowerCase() === name.toLowerCase() &&
      typeof value === "string"
    ) {
      return value;
    }
  }

  return null;
}

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

  const seconds = Number(value);

  if (Number.isFinite(seconds)) {
    return Math.max(0, seconds * 1_000);
  }

  const retryDate = Date.parse(value);

  if (Number.isNaN(retryDate)) {
    return null;
  }

  return Math.max(0, retryDate - Date.now());
}

function isTemporaryRateLimitError(
  error: unknown,
): error is OpenAI.APIError {
  if (!(error instanceof OpenAI.APIError)) {
    return false;
  }

  if (error.status !== 429) {
    return false;
  }

  return !error.code || error.code === "rate_limit_exceeded";
}

function calculateDelay(
  retryCount: number,
  retryAfterMilliseconds: number | null,
): number {
  const exponentialDelay = Math.min(
    MAX_DELAY_MS,
    BASE_DELAY_MS * 2 ** retryCount,
  );

  const minimumDelay = Math.max(
    retryAfterMilliseconds ?? 0,
    exponentialDelay,
  );

  const jitter = Math.random() * JITTER_MS;

  return minimumDelay + jitter;
}

export async function createResponseWithRetry(
  input: string,
): Promise<OpenAI.Responses.Response> {
  for (let retryCount = 0; ; retryCount += 1) {
    try {
      return await client.responses.create({
        model,
        input,
      });
    } catch (error) {
      if (!isTemporaryRateLimitError(error)) {
        throw error;
      }

      if (retryCount >= MAX_RETRIES) {
        console.error("OpenAI APIの最大リトライ回数に達しました。", {
          code: error.code,
          requestId: error.request_id,
          message: error.message,
        });

        throw error;
      }

      const retryAfterHeader = readHeader(
        error.headers,
        "retry-after",
      );

      const retryAfterMilliseconds =
        parseRetryAfterMilliseconds(retryAfterHeader);

      const delay = calculateDelay(
        retryCount,
        retryAfterMilliseconds,
      );

      console.warn("OpenAI APIのレート制限を検出しました。", {
        retryCount: retryCount + 1,
        waitMilliseconds: Math.round(delay),
        requestId: error.request_id,
        code: error.code,
      });

      await sleep(delay);
    }
  }
}

async function main(): Promise<void> {
  try {
    const response = await createResponseWithRetry(
      "Node.jsで安全にAPIをリトライする方法を説明してください。",
    );

    console.log(response.output_text);
  } catch (error) {
    console.error("回答の生成に失敗しました。", error);
    process.exitCode = 1;
  }
}

void main();

import OpenAI from "openai";

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

const { data, response } = await client.responses
  .create({
    model: process.env.OPENAI_MODEL!,
    input: "レート制限について説明してください。",
  })
  .withResponse();

console.log({
  remainingRequests: response.headers.get(
    "x-ratelimit-remaining-requests",
  ),
  remainingTokens: response.headers.get(
    "x-ratelimit-remaining-tokens",
  ),
  resetRequests: response.headers.get(
    "x-ratelimit-reset-requests",
  ),
  resetTokens: response.headers.get(
    "x-ratelimit-reset-tokens",
  ),
  requestId: response.headers.get("x-request-id"),
});

console.log(data.output_text);

async function mapWithConcurrency<T, R>(
  items: readonly T[],
  concurrency: number,
  worker: (item: T, index: number) => Promise<R>,
): Promise<R[]> {
  if (!Number.isInteger(concurrency) || concurrency < 1) {
    throw new Error("concurrencyには1以上の整数を指定してください。");
  }

  const results = new Array<R>(items.length);
  let nextIndex = 0;

  async function runWorker(): Promise<void> {
    while (true) {
      const currentIndex = nextIndex;
      nextIndex += 1;

      if (currentIndex >= items.length) {
        return;
      }

      results[currentIndex] = await worker(
        items[currentIndex]!,
        currentIndex,
      );
    }
  }

  const workerCount = Math.min(concurrency, items.length);

  await Promise.all(
    Array.from({ length: workerCount }, () => runWorker()),
  );

  return results;
}

const prompts = [
  "JavaScriptとは何ですか。",
  "TypeScriptとは何ですか。",
  "Node.jsとは何ですか。",
  "Reactとは何ですか。",
  "Next.jsとは何ですか。",
];

const responses = await mapWithConcurrency(
  prompts,
  2,
  async (prompt) => {
    const response = await createResponseWithRetry(prompt);
    return response.output_text;
  },
);

console.log(responses);

while (true) {
  try {
    return await client.responses.create({
      model,
      input: "回答を生成してください。",
    });
  } catch {
    // 待機せずに即時リトライしている
  }
}