opencode-anthropic-fix 0.0.14

package/lib/backoff.mjs

@@ -0,0 +1,217 @@
+/**
+ * @typedef {'AUTH_FAILED' | 'QUOTA_EXHAUSTED' | 'RATE_LIMIT_EXCEEDED'} RateLimitReason
+ */
+
+const QUOTA_EXHAUSTED_BACKOFFS = [60_000, 300_000, 1_800_000, 7_200_000];
+const AUTH_FAILED_BACKOFF = 5_000;
+const RATE_LIMIT_EXCEEDED_BACKOFF = 30_000;
+const MIN_BACKOFF_MS = 2_000;
+
+/**
+ * Parse the Retry-After header from a response.
+ * Supports both seconds (integer) and HTTP-date formats.
+ * @param {Response} response
+ * @returns {number | null} Retry-after duration in milliseconds, or null
+ */
+export function parseRetryAfterHeader(response) {
+  const header = response.headers.get("retry-after");
+  if (!header) return null;
+
+  // Try as integer (seconds)
+  const seconds = parseInt(header, 10);
+  if (!isNaN(seconds) && seconds > 0) {
+    return seconds * 1000;
+  }
+
+  // Try as HTTP-date
+  const date = new Date(header);
+  if (!isNaN(date.getTime())) {
+    const ms = date.getTime() - Date.now();
+    return ms > 0 ? ms : null;
+  }
+
+  return null;
+}
+
+/**
+ * Parse normalized error signals from a response body.
+ * Accepts raw strings, parsed objects, or null.
+ * @param {string | object | null | undefined} body
+ * @returns {{ errorType: string, message: string, text: string }}
+ */
+function extractErrorSignals(body) {
+  let errorType = "";
+  let message = "";
+  let text = "";
+
+  if (body == null) {
+    return { errorType, message, text };
+  }
+
+  if (typeof body === "string") {
+    text = body.toLowerCase();
+    try {
+      const parsed = JSON.parse(body);
+      errorType = String(parsed?.error?.type || "").toLowerCase();
+      message = String(parsed?.error?.message || "").toLowerCase();
+    } catch {
+      // Not JSON — use raw text only.
+    }
+    return { errorType, message, text };
+  }
+
+  if (typeof body === "object") {
+    errorType = String(body?.error?.type || "").toLowerCase();
+    message = String(body?.error?.message || "").toLowerCase();
+    try {
+      text = JSON.stringify(body).toLowerCase();
+    } catch {
+      text = "";
+    }
+  }
+
+  return { errorType, message, text };
+}
+
+/**
+ * Determine whether a response body contains account-specific error language
+ * (rate limit, quota, billing, auth, permission) as opposed to service-wide errors.
+ * @param {string | object | null | undefined} body
+ * @returns {boolean}
+ */
+function bodyHasAccountError(body) {
+  const { errorType, message, text } = extractErrorSignals(body);
+
+  const typeSignals = [
+    "rate_limit",
+    "quota",
+    "billing",
+    "permission",
+    "authentication",
+    "invalid_api_key",
+    "insufficient_permissions",
+    "invalid_grant",
+  ];
+
+  const messageSignals = [
+    "rate limit",
+    "would exceed",
+    "quota",
+    "exhausted",
+    "credit balance",
+    "billing",
+    "permission",
+    "forbidden",
+    "unauthorized",
+    "authentication",
+    "not authorized",
+  ];
+
+  return (
+    typeSignals.some((signal) => errorType.includes(signal)) ||
+    messageSignals.some((signal) => message.includes(signal)) ||
+    messageSignals.some((signal) => text.includes(signal))
+  );
+}
+
+/**
+ * Check whether an HTTP response represents an account-specific error
+ * that would benefit from switching to a different account.
+ *
+ * Account-specific: rate limits, billing, auth, permissions.
+ * Service-wide (NOT account-specific): 529, 503, 500 — switching won't help.
+ *
+ * @param {number} status
+ * @param {string | object | null} [body]
+ * @returns {boolean}
+ */
+export function isAccountSpecificError(status, body) {
+  // 429 is always account-specific (per-account rate limits)
+  if (status === 429) return true;
+
+  // 401 is always account-specific (per-account auth)
+  if (status === 401) return true;
+
+  // 400/403 are account-specific only if the body contains relevant language
+  if ((status === 400 || status === 403) && body) {
+    return bodyHasAccountError(body);
+  }
+
+  // Everything else (529, 503, 500, etc.) is service-wide
+  return false;
+}
+
+/**
+ * Parse the rate limit reason from an HTTP status and response body.
+ * Only called for account-specific errors.
+ * @param {number} status
+ * @param {string | object | null} [body]
+ * @returns {RateLimitReason}
+ */
+export function parseRateLimitReason(status, body) {
+  const { errorType, message, text } = extractErrorSignals(body);
+
+  const authSignals = [
+    "authentication",
+    "invalid_api_key",
+    "invalid api key",
+    "invalid_grant",
+    "unauthorized",
+    "invalid access token",
+    "expired token",
+  ];
+
+  const isAuthFailure =
+    status === 401 ||
+    authSignals.some((signal) => errorType.includes(signal)) ||
+    authSignals.some((signal) => message.includes(signal)) ||
+    authSignals.some((signal) => text.includes(signal));
+
+  if (isAuthFailure) {
+    return "AUTH_FAILED";
+  }
+
+  if (
+    errorType.includes("quota") ||
+    errorType.includes("billing") ||
+    errorType.includes("permission") ||
+    errorType.includes("insufficient_permissions") ||
+    message.includes("quota") ||
+    message.includes("exhausted") ||
+    message.includes("credit balance") ||
+    message.includes("billing") ||
+    message.includes("permission") ||
+    message.includes("forbidden") ||
+    text.includes("permission")
+  ) {
+    return "QUOTA_EXHAUSTED";
+  }
+
+  return "RATE_LIMIT_EXCEEDED";
+}
+
+/**
+ * Calculate backoff duration in milliseconds.
+ * @param {RateLimitReason} reason
+ * @param {number} consecutiveFailures - Zero-based count of consecutive failures
+ * @param {number | null} [retryAfterMs] - Value from Retry-After header
+ * @returns {number}
+ */
+export function calculateBackoffMs(reason, consecutiveFailures, retryAfterMs) {
+  // Retry-After header takes precedence
+  if (retryAfterMs && retryAfterMs > 0) {
+    return Math.max(retryAfterMs, MIN_BACKOFF_MS);
+  }
+
+  switch (reason) {
+    case "AUTH_FAILED":
+      return AUTH_FAILED_BACKOFF;
+    case "QUOTA_EXHAUSTED": {
+      const index = Math.min(consecutiveFailures, QUOTA_EXHAUSTED_BACKOFFS.length - 1);
+      return QUOTA_EXHAUSTED_BACKOFFS[index];
+    }
+    case "RATE_LIMIT_EXCEEDED":
+    default:
+      return RATE_LIMIT_EXCEEDED_BACKOFF;
+  }
+}

package/lib/backoff.test.mjs

@@ -0,0 +1,296 @@
+import { describe, it, expect } from "vitest";
+import { parseRateLimitReason, calculateBackoffMs, parseRetryAfterHeader, isAccountSpecificError } from "./backoff.mjs";
+
+// ---------------------------------------------------------------------------
+// isAccountSpecificError
+// ---------------------------------------------------------------------------
+
+describe("isAccountSpecificError", () => {
+  it("returns true for 429 (always account-specific)", () => {
+    expect(isAccountSpecificError(429, null)).toBe(true);
+  });
+
+  it("returns true for 429 even without body", () => {
+    expect(isAccountSpecificError(429)).toBe(true);
+  });
+
+  it("returns true for 401 (always account-specific)", () => {
+    expect(isAccountSpecificError(401, null)).toBe(true);
+  });
+
+  it("returns true for 400 with rate limit language in body", () => {
+    expect(isAccountSpecificError(400, "This request would exceed your account's rate limit")).toBe(true);
+  });
+
+  it("returns true for 400 with quota language in body", () => {
+    expect(isAccountSpecificError(400, "Your quota has been exhausted")).toBe(true);
+  });
+
+  it("returns true for 400 with credit balance language in body", () => {
+    expect(isAccountSpecificError(400, "Your credit balance is too low to complete this request")).toBe(true);
+  });
+
+  it("returns true for 400 with billing language in body", () => {
+    expect(isAccountSpecificError(400, "Billing issue on your account")).toBe(true);
+  });
+
+  it("returns true for 403 with permission language in body", () => {
+    expect(isAccountSpecificError(403, "You do not have permission to access this model")).toBe(true);
+  });
+
+  it("returns true for 403 permission_error type in JSON body", () => {
+    expect(
+      isAccountSpecificError(403, JSON.stringify({ error: { type: "permission_error", message: "Forbidden" } })),
+    ).toBe(true);
+  });
+
+  it("returns true for 403 authentication_error type in JSON body", () => {
+    expect(
+      isAccountSpecificError(403, JSON.stringify({ error: { type: "authentication_error", message: "Unauthorized" } })),
+    ).toBe(true);
+  });
+
+  it("returns true for object body with account-specific error type", () => {
+    expect(
+      isAccountSpecificError(400, {
+        error: { type: "rate_limit_error", message: "too many requests" },
+      }),
+    ).toBe(true);
+  });
+
+  it("returns false for 400 without account-specific language", () => {
+    expect(isAccountSpecificError(400, "Invalid request body")).toBe(false);
+  });
+
+  it("returns false for 400 with no body", () => {
+    expect(isAccountSpecificError(400, null)).toBe(false);
+  });
+
+  it("returns false for 403 with no body", () => {
+    expect(isAccountSpecificError(403, null)).toBe(false);
+  });
+
+  it("returns false for 500 (service-wide)", () => {
+    expect(isAccountSpecificError(500, null)).toBe(false);
+  });
+
+  it("returns false for 503 (service-wide)", () => {
+    expect(isAccountSpecificError(503, null)).toBe(false);
+  });
+
+  it("returns false for 529 (service-wide)", () => {
+    expect(isAccountSpecificError(529, null)).toBe(false);
+  });
+
+  it("returns false for 200", () => {
+    expect(isAccountSpecificError(200, null)).toBe(false);
+  });
+
+  it("is case-insensitive for body matching", () => {
+    expect(isAccountSpecificError(400, "RATE LIMIT exceeded")).toBe(true);
+    expect(isAccountSpecificError(400, "QUOTA Exhausted")).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseRateLimitReason
+// ---------------------------------------------------------------------------
+
+describe("parseRateLimitReason", () => {
+  it("returns QUOTA_EXHAUSTED for 429 with quota in error type", () => {
+    const body = JSON.stringify({
+      error: { type: "quota_exceeded", message: "You have exceeded your quota" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("QUOTA_EXHAUSTED");
+  });
+
+  it("returns QUOTA_EXHAUSTED for 429 with exhausted in message", () => {
+    const body = JSON.stringify({
+      error: { type: "rate_error", message: "Token quota exhausted" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("QUOTA_EXHAUSTED");
+  });
+
+  it("returns QUOTA_EXHAUSTED for credit balance message", () => {
+    const body = JSON.stringify({
+      error: { message: "Your credit balance is too low" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("QUOTA_EXHAUSTED");
+  });
+
+  it("returns QUOTA_EXHAUSTED for billing message", () => {
+    const body = JSON.stringify({
+      error: { message: "Billing issue on account" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("QUOTA_EXHAUSTED");
+  });
+
+  it("returns AUTH_FAILED for 401 status", () => {
+    expect(parseRateLimitReason(401, null)).toBe("AUTH_FAILED");
+  });
+
+  it("returns QUOTA_EXHAUSTED for permission_error type", () => {
+    const body = JSON.stringify({
+      error: { type: "permission_error", message: "Forbidden" },
+    });
+    expect(parseRateLimitReason(403, body)).toBe("QUOTA_EXHAUSTED");
+  });
+
+  it("returns AUTH_FAILED for authentication_error type", () => {
+    const body = JSON.stringify({
+      error: { type: "authentication_error", message: "Unauthorized" },
+    });
+    expect(parseRateLimitReason(403, body)).toBe("AUTH_FAILED");
+  });
+
+  it("returns AUTH_FAILED for invalid_api_key message", () => {
+    const body = JSON.stringify({
+      error: { type: "invalid_request_error", message: "Invalid API key" },
+    });
+    expect(parseRateLimitReason(400, body)).toBe("AUTH_FAILED");
+  });
+
+  it("returns RATE_LIMIT_EXCEEDED for 429 with rate limit message", () => {
+    const body = JSON.stringify({
+      error: { type: "rate_limit_error", message: "Rate limit exceeded" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("returns RATE_LIMIT_EXCEEDED for 429 with too many requests", () => {
+    const body = JSON.stringify({
+      error: { message: "Too many requests" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("returns RATE_LIMIT_EXCEEDED for 429 with per minute message", () => {
+    const body = JSON.stringify({
+      error: { message: "Exceeded 60 requests per minute" },
+    });
+    expect(parseRateLimitReason(429, body)).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("defaults to RATE_LIMIT_EXCEEDED for 429 with no body", () => {
+    expect(parseRateLimitReason(429, null)).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("defaults to RATE_LIMIT_EXCEEDED for 429 with unparseable body", () => {
+    expect(parseRateLimitReason(429, "not json")).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("defaults to RATE_LIMIT_EXCEEDED for unrecognized status", () => {
+    expect(parseRateLimitReason(418, null)).toBe("RATE_LIMIT_EXCEEDED");
+  });
+
+  it("handles body as object (not string)", () => {
+    const body = { error: { type: "quota_exceeded", message: "quota" } };
+    expect(parseRateLimitReason(429, body)).toBe("QUOTA_EXHAUSTED");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// calculateBackoffMs
+// ---------------------------------------------------------------------------
+
+describe("calculateBackoffMs", () => {
+  it("uses Retry-After header when provided", () => {
+    expect(calculateBackoffMs("RATE_LIMIT_EXCEEDED", 0, 5000)).toBe(5000);
+  });
+
+  it("enforces minimum backoff for Retry-After", () => {
+    expect(calculateBackoffMs("RATE_LIMIT_EXCEEDED", 0, 500)).toBe(2000);
+  });
+
+  it("ignores null Retry-After", () => {
+    const result = calculateBackoffMs("RATE_LIMIT_EXCEEDED", 0, null);
+    expect(result).toBe(30_000);
+  });
+
+  it("ignores zero Retry-After", () => {
+    const result = calculateBackoffMs("RATE_LIMIT_EXCEEDED", 0, 0);
+    expect(result).toBe(30_000);
+  });
+
+  it("escalates QUOTA_EXHAUSTED backoffs", () => {
+    expect(calculateBackoffMs("QUOTA_EXHAUSTED", 0)).toBe(60_000);
+    expect(calculateBackoffMs("QUOTA_EXHAUSTED", 1)).toBe(300_000);
+    expect(calculateBackoffMs("QUOTA_EXHAUSTED", 2)).toBe(1_800_000);
+    expect(calculateBackoffMs("QUOTA_EXHAUSTED", 3)).toBe(7_200_000);
+  });
+
+  it("caps QUOTA_EXHAUSTED at max tier", () => {
+    expect(calculateBackoffMs("QUOTA_EXHAUSTED", 100)).toBe(7_200_000);
+  });
+
+  it("returns fixed backoff for RATE_LIMIT_EXCEEDED", () => {
+    expect(calculateBackoffMs("RATE_LIMIT_EXCEEDED", 0)).toBe(30_000);
+    expect(calculateBackoffMs("RATE_LIMIT_EXCEEDED", 5)).toBe(30_000);
+  });
+
+  it("returns short fixed backoff for AUTH_FAILED", () => {
+    expect(calculateBackoffMs("AUTH_FAILED", 0)).toBe(5_000);
+    expect(calculateBackoffMs("AUTH_FAILED", 5)).toBe(5_000);
+  });
+
+  it("uses default (RATE_LIMIT_EXCEEDED) for unknown reason", () => {
+    expect(calculateBackoffMs("SOMETHING_ELSE", 0)).toBe(30_000);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseRetryAfterHeader
+// ---------------------------------------------------------------------------
+
+describe("parseRetryAfterHeader", () => {
+  it("returns null when no header present", () => {
+    const response = new Response(null, { headers: {} });
+    expect(parseRetryAfterHeader(response)).toBeNull();
+  });
+
+  it("parses integer seconds", () => {
+    const response = new Response(null, {
+      headers: { "retry-after": "30" },
+    });
+    expect(parseRetryAfterHeader(response)).toBe(30_000);
+  });
+
+  it("parses HTTP-date format", () => {
+    const futureDate = new Date(Date.now() + 60_000);
+    const response = new Response(null, {
+      headers: { "retry-after": futureDate.toUTCString() },
+    });
+    const result = parseRetryAfterHeader(response);
+    expect(result).toBeGreaterThan(50_000);
+    expect(result).toBeLessThanOrEqual(61_000);
+  });
+
+  it("returns null for past HTTP-date", () => {
+    const pastDate = new Date(Date.now() - 60_000);
+    const response = new Response(null, {
+      headers: { "retry-after": pastDate.toUTCString() },
+    });
+    expect(parseRetryAfterHeader(response)).toBeNull();
+  });
+
+  it("returns null for invalid header value", () => {
+    const response = new Response(null, {
+      headers: { "retry-after": "not-a-number-or-date" },
+    });
+    expect(parseRetryAfterHeader(response)).toBeNull();
+  });
+
+  it("returns null for zero seconds", () => {
+    const response = new Response(null, {
+      headers: { "retry-after": "0" },
+    });
+    expect(parseRetryAfterHeader(response)).toBeNull();
+  });
+
+  it("returns null for negative seconds", () => {
+    const response = new Response(null, {
+      headers: { "retry-after": "-5" },
+    });
+    expect(parseRetryAfterHeader(response)).toBeNull();
+  });
+});