opencode-anthropic-fix 0.2.1 → 0.3.0

package/lib/adaptive-thinking-models.test.mjs

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { isAdaptiveThinkingModel, isFable5Model, isMythos5Model } from "../index.mjs";
-
-describe("Claude 5 adaptive thinking model predicates", () => {
-  test("isFable5Model matches version-anchored fable 5 model names", () => {
-    expect(isFable5Model("claude-fable-5")).toBe(true);
-    expect(isFable5Model("anthropic/claude-fable-5")).toBe(true);
-  });
-
-  test("isFable5Model rejects non-fable-5 model names", () => {
-    expect(isFable5Model("claude-opus-4-8")).toBe(false);
-    expect(isFable5Model("claude-haiku-4-5")).toBe(false);
-    expect(isFable5Model("")).toBe(false);
-  });
-
-  test("isMythos5Model matches version-anchored mythos 5 model names", () => {
-    expect(isMythos5Model("claude-mythos-5")).toBe(true);
-  });
-
-  test("isMythos5Model rejects non-mythos-5 model names", () => {
-    expect(isMythos5Model("claude-opus-4-8")).toBe(false);
-    expect(isMythos5Model("claude-haiku-4-5")).toBe(false);
-    expect(isMythos5Model("")).toBe(false);
-  });
-
-  test("isAdaptiveThinkingModel includes fable 5 models", () => {
-    expect(isAdaptiveThinkingModel("claude-fable-5")).toBe(true);
-  });
-});

package/lib/backoff.test.mjs

@@ -1,411 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  parseRateLimitReason,
-  calculateBackoffMs,
-  parseRetryAfterHeader,
-  parseUnifiedResetMsHeader,
-  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 JSON error message", () => {
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({
-          error: { type: "invalid_request_error", message: "This request would exceed your account's rate limit" },
-        }),
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for 400 with quota language in JSON error message", () => {
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({ error: { type: "invalid_request_error", message: "Your quota has been exhausted" } }),
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for 400 with credit balance language in JSON error message", () => {
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({
-          error: { type: "invalid_request_error", message: "Your credit balance is too low to complete this request" },
-        }),
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for 400 with billing language in JSON error message", () => {
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({ error: { type: "billing_error", message: "Billing issue on your account" } }),
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for 403 with permission language in JSON error message", () => {
-    expect(
-      isAccountSpecificError(
-        403,
-        JSON.stringify({
-          error: { type: "permission_error", message: "You do not have permission to access this model" },
-        }),
-      ),
-    ).toBe(true);
-  });
-
-  it("returns false for plain text body without JSON structure (no false positives)", () => {
-    // Plain text bodies that happen to contain keywords should NOT match
-    // — only structured error.type and error.message fields are checked
-    expect(isAccountSpecificError(400, "This request would exceed your account's rate limit")).toBe(false);
-    expect(isAccountSpecificError(400, "Billing issue on your account")).toBe(false);
-    expect(isAccountSpecificError(403, "You do not have permission to access this model")).toBe(false);
-  });
-
-  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 JSON error message matching", () => {
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({ error: { type: "invalid_request_error", message: "RATE LIMIT exceeded" } }),
-      ),
-    ).toBe(true);
-    expect(
-      isAccountSpecificError(
-        400,
-        JSON.stringify({ error: { type: "invalid_request_error", message: "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();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// parseUnifiedResetMsHeader
-// ---------------------------------------------------------------------------
-
-describe("parseUnifiedResetMsHeader", () => {
-  it("returns null when no unified-reset header present", () => {
-    const response = new Response(null, { headers: {} });
-    expect(parseUnifiedResetMsHeader(response)).toBeNull();
-  });
-
-  it("returns ~ms-until-reset for a future epoch (seconds)", () => {
-    const futureEpochSeconds = Math.floor(Date.now() / 1000) + 120;
-    const response = new Response(null, {
-      headers: { "anthropic-ratelimit-unified-reset": String(futureEpochSeconds) },
-    });
-    const result = parseUnifiedResetMsHeader(response);
-    expect(result).toBeGreaterThan(110_000);
-    expect(result).toBeLessThanOrEqual(120_000);
-  });
-
-  it("returns null for a non-numeric value (NaN)", () => {
-    const response = new Response(null, {
-      headers: { "anthropic-ratelimit-unified-reset": "not-a-number" },
-    });
-    expect(parseUnifiedResetMsHeader(response)).toBeNull();
-  });
-
-  it("returns null for a past epoch (<= now)", () => {
-    const pastEpochSeconds = Math.floor(Date.now() / 1000) - 60;
-    const response = new Response(null, {
-      headers: { "anthropic-ratelimit-unified-reset": String(pastEpochSeconds) },
-    });
-    expect(parseUnifiedResetMsHeader(response)).toBeNull();
-  });
-
-  it("falls back to overage-reset when unified-reset is absent", () => {
-    const futureEpochSeconds = Math.floor(Date.now() / 1000) + 90;
-    const response = new Response(null, {
-      headers: { "anthropic-ratelimit-unified-overage-reset": String(futureEpochSeconds) },
-    });
-    const result = parseUnifiedResetMsHeader(response);
-    expect(result).toBeGreaterThan(80_000);
-    expect(result).toBeLessThanOrEqual(90_000);
-  });
-
-  it("prefers unified-reset over overage-reset when both present", () => {
-    const resetEpoch = Math.floor(Date.now() / 1000) + 120;
-    const overageEpoch = Math.floor(Date.now() / 1000) + 300;
-    const response = new Response(null, {
-      headers: {
-        "anthropic-ratelimit-unified-reset": String(resetEpoch),
-        "anthropic-ratelimit-unified-overage-reset": String(overageEpoch),
-      },
-    });
-    const result = parseUnifiedResetMsHeader(response);
-    expect(result).toBeGreaterThan(110_000);
-    expect(result).toBeLessThanOrEqual(120_000);
-  });
-});