@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/request/metadata.ts

@@ -5,90 +5,90 @@
 import type { RequestBodyMetadata, RequestMetadata } from "../types.js";
 
 export function extractFileIds(parsed: unknown): string[] {
-  if (!parsed || typeof parsed !== "object") return [];
-  const obj = parsed as Record<string, unknown>;
+    if (!parsed || typeof parsed !== "object") return [];
+    const obj = parsed as Record<string, unknown>;
 
-  const ids: string[] = [];
+    const ids: string[] = [];
 
-  const collectFromContent = (content: unknown): void => {
-    if (!Array.isArray(content)) return;
-    for (const block of content) {
-      if (!block || typeof block !== "object") continue;
-      const b = block as Record<string, unknown>;
-      if ((b.type === "document" || b.type === "file") && b.source && typeof b.source === "object") {
-        const src = b.source as Record<string, unknown>;
-        if (typeof src.file_id === "string") {
-          ids.push(src.file_id);
+    const collectFromContent = (content: unknown): void => {
+        if (!Array.isArray(content)) return;
+        for (const block of content) {
+            if (!block || typeof block !== "object") continue;
+            const b = block as Record<string, unknown>;
+            if ((b.type === "document" || b.type === "file") && b.source && typeof b.source === "object") {
+                const src = b.source as Record<string, unknown>;
+                if (typeof src.file_id === "string") {
+                    ids.push(src.file_id);
+                }
+            }
         }
-      }
-    }
-  };
+    };
 
-  if (Array.isArray(obj.messages)) {
-    for (const msg of obj.messages) {
-      if (!msg || typeof msg !== "object") continue;
-      collectFromContent((msg as Record<string, unknown>).content);
+    if (Array.isArray(obj.messages)) {
+        for (const msg of obj.messages) {
+            if (!msg || typeof msg !== "object") continue;
+            collectFromContent((msg as Record<string, unknown>).content);
+        }
     }
-  }
 
-  if (Array.isArray(obj.system)) {
-    collectFromContent(obj.system);
-  }
+    if (Array.isArray(obj.system)) {
+        collectFromContent(obj.system);
+    }
 
-  return ids;
+    return ids;
 }
 
 export function parseRequestBodyMetadata(
-  body: string | undefined,
-  debugLog?: (...args: unknown[]) => void,
+    body: string | undefined,
+    debugLog?: (...args: unknown[]) => void,
 ): RequestBodyMetadata {
-  if (!body || typeof body !== "string") {
-    return { model: "", tools: [], messages: [], hasFileReferences: false };
-  }
+    if (!body || typeof body !== "string") {
+        return { model: "", tools: [], messages: [], hasFileReferences: false };
+    }
 
-  try {
-    const parsed = JSON.parse(body);
-    const model = typeof parsed?.model === "string" ? parsed.model : "";
-    const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
-    const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
-    const hasFileReferences = extractFileIds(parsed).length > 0;
-    return { model, tools, messages, hasFileReferences };
-  } catch (err) {
-    debugLog?.("extractFileIds failed:", (err as Error).message);
-    return { model: "", tools: [], messages: [], hasFileReferences: false };
-  }
+    try {
+        const parsed = JSON.parse(body);
+        const model = typeof parsed?.model === "string" ? parsed.model : "";
+        const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
+        const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+        const hasFileReferences = extractFileIds(parsed).length > 0;
+        return { model, tools, messages, hasFileReferences };
+    } catch (err) {
+        debugLog?.("extractFileIds failed:", (err as Error).message);
+        return { model: "", tools: [], messages: [], hasFileReferences: false };
+    }
 }
 
 export function getAccountIdentifier(account: { id?: string; accountUuid?: string } | null | undefined): string {
-  // Prefer env-provided account UUID (v2.1.51+), then account record fields
-  const envUuid = process.env.CLAUDE_CODE_ACCOUNT_UUID?.trim();
-  if (envUuid) return envUuid;
-  if (account?.accountUuid && typeof account.accountUuid === "string") {
-    return account.accountUuid;
-  }
-  if (account?.id && typeof account.id === "string") {
-    return account.id;
-  }
-  return "";
+    // Prefer env-provided account UUID (v2.1.51+), then account record fields
+    const envUuid = process.env.CLAUDE_CODE_ACCOUNT_UUID?.trim();
+    if (envUuid) return envUuid;
+    if (account?.accountUuid && typeof account.accountUuid === "string") {
+        return account.accountUuid;
+    }
+    if (account?.id && typeof account.id === "string") {
+        return account.id;
+    }
+    return "";
 }
 
 export function buildRequestMetadata(input: {
-  persistentUserId: string;
-  accountId: string;
-  sessionId: string;
+    persistentUserId: string;
+    accountId: string;
+    sessionId: string;
 }): RequestMetadata {
-  const metadata: RequestMetadata = {
-    user_id: JSON.stringify({
-      device_id: input.persistentUserId,
-      account_uuid: input.accountId,
-      session_id: input.sessionId,
-    }),
-  };
+    const metadata: RequestMetadata = {
+        user_id: JSON.stringify({
+            device_id: input.persistentUserId,
+            account_uuid: input.accountId,
+            session_id: input.sessionId,
+        }),
+    };
 
-  const orgUuid = process.env.CLAUDE_CODE_ORGANIZATION_UUID?.trim();
-  if (orgUuid) metadata.organization_uuid = orgUuid;
-  const userEmail = process.env.CLAUDE_CODE_USER_EMAIL?.trim();
-  if (userEmail) metadata.user_email = userEmail;
+    const orgUuid = process.env.CLAUDE_CODE_ORGANIZATION_UUID?.trim();
+    if (orgUuid) metadata.organization_uuid = orgUuid;
+    const userEmail = process.env.CLAUDE_CODE_USER_EMAIL?.trim();
+    if (userEmail) metadata.user_email = userEmail;
 
-  return metadata;
+    return metadata;
 }

package/src/request/retry.test.ts

@@ -2,178 +2,178 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { calculateRetryDelay, fetchWithRetry, shouldRetryStatus } from "./retry.js";
 
 function makeResponse(status: number, headers?: HeadersInit): Response {
-  return new Response(null, {
-    status,
-    headers,
-  });
+    return new Response(null, {
+        status,
+        headers,
+    });
 }
 
 const FAST_RETRY_CONFIG = {
-  initialDelayMs: 1,
-  maxDelayMs: 8,
-  jitterFraction: 0,
+    initialDelayMs: 1,
+    maxDelayMs: 8,
+    jitterFraction: 0,
 };
 
 describe("shouldRetryStatus", () => {
-  it("honors x-should-retry overrides before status logic", () => {
-    expect(shouldRetryStatus(400, true)).toBe(true);
-    expect(shouldRetryStatus(503, false)).toBe(false);
-  });
-
-  it("retries only the supported fallback statuses", () => {
-    expect(shouldRetryStatus(408, null)).toBe(true);
-    expect(shouldRetryStatus(409, null)).toBe(true);
-    expect(shouldRetryStatus(429, null)).toBe(true);
-    expect(shouldRetryStatus(529, null)).toBe(true);
-    expect(shouldRetryStatus(400, null)).toBe(false);
-  });
+    it("honors x-should-retry overrides before status logic", () => {
+        expect(shouldRetryStatus(400, true)).toBe(true);
+        expect(shouldRetryStatus(503, false)).toBe(false);
+    });
+
+    it("retries only the supported fallback statuses", () => {
+        expect(shouldRetryStatus(408, null)).toBe(true);
+        expect(shouldRetryStatus(409, null)).toBe(true);
+        expect(shouldRetryStatus(429, null)).toBe(true);
+        expect(shouldRetryStatus(529, null)).toBe(true);
+        expect(shouldRetryStatus(400, null)).toBe(false);
+    });
 });
 
 describe("calculateRetryDelay", () => {
-  it("matches the Stainless exponential backoff formula with jitter and max cap", () => {
-    vi.spyOn(Math, "random").mockReturnValue(0.5);
-
-    expect(
-      calculateRetryDelay(0, {
-        maxRetries: 2,
-        initialDelayMs: 500,
-        maxDelayMs: 8000,
-        jitterFraction: 0.25,
-      }),
-    ).toBe(438);
-
-    expect(
-      calculateRetryDelay(3, {
-        maxRetries: 2,
-        initialDelayMs: 500,
-        maxDelayMs: 8000,
-        jitterFraction: 0.25,
-      }),
-    ).toBe(3500);
-
-    expect(
-      calculateRetryDelay(5, {
-        maxRetries: 2,
-        initialDelayMs: 500,
-        maxDelayMs: 8000,
-        jitterFraction: 0.25,
-      }),
-    ).toBe(7000);
-  });
+    it("matches the Stainless exponential backoff formula with jitter and max cap", () => {
+        vi.spyOn(Math, "random").mockReturnValue(0.5);
+
+        expect(
+            calculateRetryDelay(0, {
+                maxRetries: 2,
+                initialDelayMs: 500,
+                maxDelayMs: 8000,
+                jitterFraction: 0.25,
+            }),
+        ).toBe(438);
+
+        expect(
+            calculateRetryDelay(3, {
+                maxRetries: 2,
+                initialDelayMs: 500,
+                maxDelayMs: 8000,
+                jitterFraction: 0.25,
+            }),
+        ).toBe(3500);
+
+        expect(
+            calculateRetryDelay(5, {
+                maxRetries: 2,
+                initialDelayMs: 500,
+                maxDelayMs: 8000,
+                jitterFraction: 0.25,
+            }),
+        ).toBe(7000);
+    });
 });
 
 describe("fetchWithRetry", () => {
-  beforeEach(() => {
-    vi.spyOn(Math, "random").mockReturnValue(0);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("retries a 529 once and returns the next success", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValueOnce(makeResponse(529))
-      .mockResolvedValueOnce(makeResponse(200));
-
-    const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
-
-    expect(response.status).toBe(200);
-    expect(doFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it("retries twice before succeeding on the third attempt", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValueOnce(makeResponse(529))
-      .mockResolvedValueOnce(makeResponse(529))
-      .mockResolvedValueOnce(makeResponse(200));
-
-    const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
-
-    expect(response.status).toBe(200);
-    expect(doFetch).toHaveBeenCalledTimes(3);
-  });
-
-  it("returns the last failure after exhausting the retry budget", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValueOnce(makeResponse(529))
-      .mockResolvedValueOnce(makeResponse(529))
-      .mockResolvedValueOnce(makeResponse(529));
-
-    const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
-
-    expect(response.status).toBe(529);
-    expect(doFetch).toHaveBeenCalledTimes(3);
-  });
-
-  it("does not retry when x-should-retry is false", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValue(makeResponse(503, { "x-should-retry": "false" }));
-
-    const response = await fetchWithRetry(doFetch);
-
-    expect(response.status).toBe(503);
-    expect(doFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it("prefers retry-after-ms over calculated backoff", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValueOnce(makeResponse(503, { "retry-after-ms": "2000" }))
-      .mockResolvedValueOnce(makeResponse(200));
-
-    const startedAt = Date.now();
-    const response = await fetchWithRetry(doFetch);
-    const elapsedMs = Date.now() - startedAt;
-
-    expect(response.status).toBe(200);
-    expect(doFetch).toHaveBeenCalledTimes(2);
-    expect(elapsedMs).toBeGreaterThanOrEqual(1900);
-  });
-
-  it("falls back to retry-after when retry-after-ms is absent", async () => {
-    const doFetch = vi
-      .fn<() => Promise<Response>>()
-      .mockResolvedValueOnce(makeResponse(503, { "retry-after": "3" }))
-      .mockResolvedValueOnce(makeResponse(200));
-
-    const startedAt = Date.now();
-    const response = await fetchWithRetry(doFetch);
-    const elapsedMs = Date.now() - startedAt;
-
-    expect(response.status).toBe(200);
-    expect(doFetch).toHaveBeenCalledTimes(2);
-    expect(elapsedMs).toBeGreaterThanOrEqual(2900);
-  });
-
-  it("retries thrown retryable network errors and marks the next attempt as fresh-connection", async () => {
-    const forceFreshConnectionByAttempt: boolean[] = [];
-    const doFetch = vi.fn(async ({ forceFreshConnection = false }: { forceFreshConnection?: boolean } = {}) => {
-      forceFreshConnectionByAttempt.push(forceFreshConnection);
-      if (forceFreshConnectionByAttempt.length === 1) {
-        throw Object.assign(new Error("Connection reset by server"), { code: "ECONNRESET" });
-      }
-
-      return makeResponse(200);
+    beforeEach(() => {
+        vi.spyOn(Math, "random").mockReturnValue(0);
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it("retries a 529 once and returns the next success", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValueOnce(makeResponse(529))
+            .mockResolvedValueOnce(makeResponse(200));
+
+        const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
+
+        expect(response.status).toBe(200);
+        expect(doFetch).toHaveBeenCalledTimes(2);
+    });
+
+    it("retries twice before succeeding on the third attempt", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValueOnce(makeResponse(529))
+            .mockResolvedValueOnce(makeResponse(529))
+            .mockResolvedValueOnce(makeResponse(200));
+
+        const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
+
+        expect(response.status).toBe(200);
+        expect(doFetch).toHaveBeenCalledTimes(3);
+    });
+
+    it("returns the last failure after exhausting the retry budget", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValueOnce(makeResponse(529))
+            .mockResolvedValueOnce(makeResponse(529))
+            .mockResolvedValueOnce(makeResponse(529));
+
+        const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
+
+        expect(response.status).toBe(529);
+        expect(doFetch).toHaveBeenCalledTimes(3);
     });
 
-    const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
+    it("does not retry when x-should-retry is false", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValue(makeResponse(503, { "x-should-retry": "false" }));
 
-    expect(response.status).toBe(200);
-    expect(doFetch).toHaveBeenCalledTimes(2);
-    expect(forceFreshConnectionByAttempt).toEqual([false, true]);
-  });
+        const response = await fetchWithRetry(doFetch);
 
-  it("does not retry user abort errors", async () => {
-    const doFetch = vi.fn(async () => {
-      throw new DOMException("The operation was aborted", "AbortError");
+        expect(response.status).toBe(503);
+        expect(doFetch).toHaveBeenCalledTimes(1);
     });
 
-    await expect(fetchWithRetry(doFetch, FAST_RETRY_CONFIG)).rejects.toThrow(/aborted/i);
-    expect(doFetch).toHaveBeenCalledTimes(1);
-  });
+    it("prefers retry-after-ms over calculated backoff", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValueOnce(makeResponse(503, { "retry-after-ms": "2000" }))
+            .mockResolvedValueOnce(makeResponse(200));
+
+        const startedAt = Date.now();
+        const response = await fetchWithRetry(doFetch);
+        const elapsedMs = Date.now() - startedAt;
+
+        expect(response.status).toBe(200);
+        expect(doFetch).toHaveBeenCalledTimes(2);
+        expect(elapsedMs).toBeGreaterThanOrEqual(1900);
+    });
+
+    it("falls back to retry-after when retry-after-ms is absent", async () => {
+        const doFetch = vi
+            .fn<() => Promise<Response>>()
+            .mockResolvedValueOnce(makeResponse(503, { "retry-after": "3" }))
+            .mockResolvedValueOnce(makeResponse(200));
+
+        const startedAt = Date.now();
+        const response = await fetchWithRetry(doFetch);
+        const elapsedMs = Date.now() - startedAt;
+
+        expect(response.status).toBe(200);
+        expect(doFetch).toHaveBeenCalledTimes(2);
+        expect(elapsedMs).toBeGreaterThanOrEqual(2900);
+    });
+
+    it("retries thrown retryable network errors and marks the next attempt as fresh-connection", async () => {
+        const forceFreshConnectionByAttempt: boolean[] = [];
+        const doFetch = vi.fn(async ({ forceFreshConnection = false }: { forceFreshConnection?: boolean } = {}) => {
+            forceFreshConnectionByAttempt.push(forceFreshConnection);
+            if (forceFreshConnectionByAttempt.length === 1) {
+                throw Object.assign(new Error("Connection reset by server"), { code: "ECONNRESET" });
+            }
+
+            return makeResponse(200);
+        });
+
+        const response = await fetchWithRetry(doFetch, FAST_RETRY_CONFIG);
+
+        expect(response.status).toBe(200);
+        expect(doFetch).toHaveBeenCalledTimes(2);
+        expect(forceFreshConnectionByAttempt).toEqual([false, true]);
+    });
+
+    it("does not retry user abort errors", async () => {
+        const doFetch = vi.fn(async () => {
+            throw new DOMException("The operation was aborted", "AbortError");
+        });
+
+        await expect(fetchWithRetry(doFetch, FAST_RETRY_CONFIG)).rejects.toThrow(/aborted/i);
+        expect(doFetch).toHaveBeenCalledTimes(1);
+    });
 });

package/src/request/retry.ts

@@ -1,95 +1,95 @@
 import {
-  isRetriableNetworkError,
-  parseRetryAfterHeader,
-  parseRetryAfterMsHeader,
-  parseShouldRetryHeader,
+    isRetriableNetworkError,
+    parseRetryAfterHeader,
+    parseRetryAfterMsHeader,
+    parseShouldRetryHeader,
 } from "../backoff.js";
 
 export interface RetryConfig {
-  maxRetries: number;
-  initialDelayMs: number;
-  maxDelayMs: number;
-  jitterFraction: number;
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    jitterFraction: number;
 }
 
 export interface RetryAttemptContext {
-  attempt: number;
-  forceFreshConnection: boolean;
+    attempt: number;
+    forceFreshConnection: boolean;
 }
 
 export interface RetryOptions extends Partial<RetryConfig> {
-  shouldRetryError?: (error: unknown) => boolean;
-  shouldRetryResponse?: (response: Response) => boolean;
+    shouldRetryError?: (error: unknown) => boolean;
+    shouldRetryResponse?: (response: Response) => boolean;
 }
 
 const DEFAULT_RETRY_CONFIG: RetryConfig = {
-  maxRetries: 2,
-  initialDelayMs: 500,
-  maxDelayMs: 8000,
-  jitterFraction: 0.25,
+    maxRetries: 2,
+    initialDelayMs: 500,
+    maxDelayMs: 8000,
+    jitterFraction: 0.25,
 };
 
 function waitFor(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 export function calculateRetryDelay(attempt: number, config: RetryConfig): number {
-  const delay = Math.min(config.initialDelayMs * Math.pow(2, attempt), config.maxDelayMs);
-  const jitter = 1 - Math.random() * config.jitterFraction;
-  return Math.round(delay * jitter);
+    const delay = Math.min(config.initialDelayMs * Math.pow(2, attempt), config.maxDelayMs);
+    const jitter = 1 - Math.random() * config.jitterFraction;
+    return Math.round(delay * jitter);
 }
 
 export function shouldRetryStatus(status: number, shouldRetryHeader: boolean | null): boolean {
-  if (shouldRetryHeader === true) return true;
-  if (shouldRetryHeader === false) return false;
-  return status === 408 || status === 409 || status === 429 || status >= 500;
+    if (shouldRetryHeader === true) return true;
+    if (shouldRetryHeader === false) return false;
+    return status === 408 || status === 409 || status === 429 || status >= 500;
 }
 
 export async function fetchWithRetry(
-  doFetch: (context: RetryAttemptContext) => Promise<Response>,
-  options: RetryOptions = {},
+    doFetch: (context: RetryAttemptContext) => Promise<Response>,
+    options: RetryOptions = {},
 ): Promise<Response> {
-  const resolvedConfig: RetryConfig = { ...DEFAULT_RETRY_CONFIG, ...options };
-  const shouldRetryError = options.shouldRetryError ?? isRetriableNetworkError;
-  const shouldRetryResponse =
-    options.shouldRetryResponse ??
-    ((response: Response) => {
-      const shouldRetryHeader = parseShouldRetryHeader(response);
-      return shouldRetryStatus(response.status, shouldRetryHeader);
-    });
-
-  let forceFreshConnection = false;
-
-  for (let attempt = 0; ; attempt++) {
-    let response: Response;
-
-    try {
-      response = await doFetch({ attempt, forceFreshConnection });
-    } catch (error) {
-      if (!shouldRetryError(error) || attempt >= resolvedConfig.maxRetries) {
-        throw error;
-      }
-
-      const delayMs = calculateRetryDelay(attempt, resolvedConfig);
-      await waitFor(delayMs);
-      forceFreshConnection = true;
-      continue;
+    const resolvedConfig: RetryConfig = { ...DEFAULT_RETRY_CONFIG, ...options };
+    const shouldRetryError = options.shouldRetryError ?? isRetriableNetworkError;
+    const shouldRetryResponse =
+        options.shouldRetryResponse ??
+        ((response: Response) => {
+            const shouldRetryHeader = parseShouldRetryHeader(response);
+            return shouldRetryStatus(response.status, shouldRetryHeader);
+        });
+
+    let forceFreshConnection = false;
+
+    for (let attempt = 0; ; attempt++) {
+        let response: Response;
+
+        try {
+            response = await doFetch({ attempt, forceFreshConnection });
+        } catch (error) {
+            if (!shouldRetryError(error) || attempt >= resolvedConfig.maxRetries) {
+                throw error;
+            }
+
+            const delayMs = calculateRetryDelay(attempt, resolvedConfig);
+            await waitFor(delayMs);
+            forceFreshConnection = true;
+            continue;
+        }
+
+        if (response.ok) {
+            return response;
+        }
+
+        if (!shouldRetryResponse(response) || attempt >= resolvedConfig.maxRetries) {
+            return response;
+        }
+
+        const delayMs =
+            parseRetryAfterMsHeader(response) ??
+            parseRetryAfterHeader(response) ??
+            calculateRetryDelay(attempt, resolvedConfig);
+
+        await waitFor(delayMs);
+        forceFreshConnection = false;
     }
-
-    if (response.ok) {
-      return response;
-    }
-
-    if (!shouldRetryResponse(response) || attempt >= resolvedConfig.maxRetries) {
-      return response;
-    }
-
-    const delayMs =
-      parseRetryAfterMsHeader(response) ??
-      parseRetryAfterHeader(response) ??
-      calculateRetryDelay(attempt, resolvedConfig);
-
-    await waitFor(delayMs);
-    forceFreshConnection = false;
-  }
 }