@vacbo/opencode-anthropic-fix 0.1.4 → 0.1.5

package/dist/opencode-anthropic-auth-plugin.js

@@ -3377,6 +3377,21 @@ var QUOTA_EXHAUSTED_BACKOFFS = [6e4, 3e5, 18e5, 72e5];
 var AUTH_FAILED_BACKOFF = 5e3;
 var RATE_LIMIT_EXCEEDED_BACKOFF = 3e4;
 var MIN_BACKOFF_MS = 2e3;
+var RETRIABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "UND_ERR_SOCKET"]);
+var NON_RETRIABLE_ERROR_NAMES = /* @__PURE__ */ new Set(["AbortError", "TimeoutError", "APIUserAbortError"]);
+var RETRIABLE_NETWORK_ERROR_MESSAGES = [
+  "bun proxy upstream error",
+  "connection reset by peer",
+  "connection reset by server",
+  "econnreset",
+  "econnrefused",
+  "epipe",
+  "etimedout",
+  "fetch failed",
+  "network connection lost",
+  "socket hang up",
+  "und_err_socket"
+];
 function parseRetryAfterHeader(response) {
   const header = response.headers.get("retry-after");
   if (!header) return null;
@@ -3463,6 +3478,54 @@ function bodyHasAccountError(body) {
   ];
   return typeSignals.some((signal) => errorType.includes(signal)) || messageSignals.some((signal) => message.includes(signal)) || messageSignals.some((signal) => text.includes(signal));
 }
+function collectErrorChain(error) {
+  const queue = [error];
+  const visited = /* @__PURE__ */ new Set();
+  const chain = [];
+  while (queue.length > 0) {
+    const candidate = queue.shift();
+    if (candidate == null || visited.has(candidate)) {
+      continue;
+    }
+    visited.add(candidate);
+    if (candidate instanceof Error) {
+      const typedCandidate = candidate;
+      chain.push(typedCandidate);
+      if (typedCandidate.cause !== void 0) {
+        queue.push(typedCandidate.cause);
+      }
+      continue;
+    }
+    if (typeof candidate === "object" && "cause" in candidate) {
+      queue.push(candidate.cause);
+    }
+  }
+  return chain;
+}
+function isRetriableNetworkError(error) {
+  if (typeof error === "string") {
+    const text = error.toLowerCase();
+    return RETRIABLE_NETWORK_ERROR_MESSAGES.some((signal) => text.includes(signal));
+  }
+  const chain = collectErrorChain(error);
+  if (chain.length === 0) {
+    return false;
+  }
+  for (const candidate of chain) {
+    if (NON_RETRIABLE_ERROR_NAMES.has(candidate.name)) {
+      return false;
+    }
+    const code = candidate.code?.toUpperCase();
+    if (code && RETRIABLE_NETWORK_ERROR_CODES.has(code)) {
+      return true;
+    }
+    const message = candidate.message.toLowerCase();
+    if (RETRIABLE_NETWORK_ERROR_MESSAGES.some((signal) => message.includes(signal))) {
+      return true;
+    }
+  }
+  return false;
+}
 function isAccountSpecificError(status, body) {
   if (status === 429) return true;
   if (status === 401) return true;
@@ -6382,20 +6445,36 @@ function shouldRetryStatus(status, shouldRetryHeader) {
   if (shouldRetryHeader === false) return false;
   return status === 408 || status === 409 || status === 429 || status >= 500;
 }
-async function fetchWithRetry(doFetch, config = {}) {
-  const resolvedConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+async function fetchWithRetry(doFetch, options = {}) {
+  const resolvedConfig = { ...DEFAULT_RETRY_CONFIG, ...options };
+  const shouldRetryError = options.shouldRetryError ?? isRetriableNetworkError;
+  const shouldRetryResponse = options.shouldRetryResponse ?? ((response) => {
+    const shouldRetryHeader = parseShouldRetryHeader(response);
+    return shouldRetryStatus(response.status, shouldRetryHeader);
+  });
+  let forceFreshConnection = false;
   for (let attempt = 0; ; attempt++) {
-    const response = await doFetch();
+    let response;
+    try {
+      response = await doFetch({ attempt, forceFreshConnection });
+    } catch (error) {
+      if (!shouldRetryError(error) || attempt >= resolvedConfig.maxRetries) {
+        throw error;
+      }
+      const delayMs2 = calculateRetryDelay(attempt, resolvedConfig);
+      await waitFor(delayMs2);
+      forceFreshConnection = true;
+      continue;
+    }
     if (response.ok) {
       return response;
     }
-    const shouldRetryHeader = parseShouldRetryHeader(response);
-    const shouldRetry = shouldRetryStatus(response.status, shouldRetryHeader);
-    if (!shouldRetry || attempt >= resolvedConfig.maxRetries) {
+    if (!shouldRetryResponse(response) || attempt >= resolvedConfig.maxRetries) {
       return response;
     }
     const delayMs = parseRetryAfterMsHeader(response) ?? parseRetryAfterHeader(response) ?? calculateRetryDelay(attempt, resolvedConfig);
     await waitFor(delayMs);
+    forceFreshConnection = false;
   }
 }
 
@@ -8250,12 +8329,33 @@ ${message}`);
                 }
                 let response;
                 const fetchInput = requestInput;
-                try {
-                  response = await fetchWithTransport(fetchInput, {
+                const buildTransportRequestInit = (headers, requestBody, forceFreshConnection) => {
+                  const requestHeadersForTransport = new Headers(headers);
+                  if (forceFreshConnection) {
+                    requestHeadersForTransport.set("connection", "close");
+                    requestHeadersForTransport.set("x-proxy-disable-keepalive", "true");
+                  } else {
+                    requestHeadersForTransport.delete("connection");
+                    requestHeadersForTransport.delete("x-proxy-disable-keepalive");
+                  }
+                  return {
                     ...requestInit,
-                    body,
-                    headers: requestHeaders
-                  });
+                    body: requestBody,
+                    headers: requestHeadersForTransport,
+                    ...forceFreshConnection ? { keepalive: false } : {}
+                  };
+                };
+                try {
+                  response = await fetchWithRetry(
+                    async ({ forceFreshConnection }) => fetchWithTransport(
+                      fetchInput,
+                      buildTransportRequestInit(requestHeaders, body, forceFreshConnection)
+                    ),
+                    {
+                      maxRetries: 2,
+                      shouldRetryResponse: () => false
+                    }
+                  );
                 } catch (err) {
                   const fetchError = err instanceof Error ? err : new Error(String(err));
                   if (accountManager && account) {
@@ -8308,7 +8408,7 @@ ${message}`);
                     });
                     let retryCount = 0;
                     const retried = await fetchWithRetry(
-                      async () => {
+                      async ({ forceFreshConnection }) => {
                         if (retryCount === 0) {
                           retryCount += 1;
                           return response;
@@ -8318,11 +8418,10 @@ ${message}`);
                         retryCount += 1;
                         const retryUrl = fetchInput instanceof Request ? fetchInput.url : fetchInput.toString();
                         const retryBody = requestContext.preparedBody === void 0 ? void 0 : cloneBodyForRetry(requestContext.preparedBody);
-                        return fetchWithTransport(retryUrl, {
-                          ...requestInit,
-                          body: retryBody,
-                          headers: headersForRetry
-                        });
+                        return fetchWithTransport(
+                          retryUrl,
+                          buildTransportRequestInit(headersForRetry, retryBody, forceFreshConnection)
+                        );
                       },
                       { maxRetries: 2 }
                     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vacbo/opencode-anthropic-fix",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "main": "dist/opencode-anthropic-auth-plugin.js",
   "bin": {
     "opencode-anthropic-auth": "dist/opencode-anthropic-auth-cli.mjs",

package/src/backoff.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   calculateBackoffMs,
   isAccountSpecificError,
+  isRetriableNetworkError,
   parseRateLimitReason,
   parseRetryAfterHeader,
   parseRetryAfterMsHeader,
@@ -235,6 +236,30 @@ describe("parseRateLimitReason", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// isRetriableNetworkError
+// ---------------------------------------------------------------------------
+
+describe("isRetriableNetworkError", () => {
+  it("returns true for retryable connection reset codes", () => {
+    const error = Object.assign(new Error("socket died"), {
+      code: "ECONNRESET",
+    });
+
+    expect(isRetriableNetworkError(error)).toBe(true);
+  });
+
+  it("returns true for Bun proxy upstream reset messages", () => {
+    expect(isRetriableNetworkError(new Error("Bun proxy upstream error: Connection reset by server"))).toBe(true);
+  });
+
+  it("returns false for user abort errors", () => {
+    const error = new DOMException("The operation was aborted", "AbortError");
+
+    expect(isRetriableNetworkError(error)).toBe(false);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // calculateBackoffMs
 // ---------------------------------------------------------------------------

package/src/backoff.ts

@@ -4,6 +4,26 @@ 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;
+const RETRIABLE_NETWORK_ERROR_CODES = new Set(["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "UND_ERR_SOCKET"]);
+const NON_RETRIABLE_ERROR_NAMES = new Set(["AbortError", "TimeoutError", "APIUserAbortError"]);
+const RETRIABLE_NETWORK_ERROR_MESSAGES = [
+  "bun proxy upstream error",
+  "connection reset by peer",
+  "connection reset by server",
+  "econnreset",
+  "econnrefused",
+  "epipe",
+  "etimedout",
+  "fetch failed",
+  "network connection lost",
+  "socket hang up",
+  "und_err_socket",
+];
+
+interface ErrorWithCode extends Error {
+  code?: string;
+  cause?: unknown;
+}
 
 /**
  * Parse the Retry-After header from a response.
@@ -132,6 +152,69 @@ function bodyHasAccountError(body: string | object | null | undefined): boolean
   );
 }
 
+function collectErrorChain(error: unknown): ErrorWithCode[] {
+  const queue: unknown[] = [error];
+  const visited = new Set<unknown>();
+  const chain: ErrorWithCode[] = [];
+
+  while (queue.length > 0) {
+    const candidate = queue.shift();
+    if (candidate == null || visited.has(candidate)) {
+      continue;
+    }
+
+    visited.add(candidate);
+
+    if (candidate instanceof Error) {
+      const typedCandidate = candidate as ErrorWithCode;
+      chain.push(typedCandidate);
+      if (typedCandidate.cause !== undefined) {
+        queue.push(typedCandidate.cause);
+      }
+      continue;
+    }
+
+    if (typeof candidate === "object" && "cause" in candidate) {
+      queue.push((candidate as { cause?: unknown }).cause);
+    }
+  }
+
+  return chain;
+}
+
+/**
+ * Check whether an error represents a transient transport/network failure.
+ */
+export function isRetriableNetworkError(error: unknown): boolean {
+  if (typeof error === "string") {
+    const text = error.toLowerCase();
+    return RETRIABLE_NETWORK_ERROR_MESSAGES.some((signal) => text.includes(signal));
+  }
+
+  const chain = collectErrorChain(error);
+  if (chain.length === 0) {
+    return false;
+  }
+
+  for (const candidate of chain) {
+    if (NON_RETRIABLE_ERROR_NAMES.has(candidate.name)) {
+      return false;
+    }
+
+    const code = candidate.code?.toUpperCase();
+    if (code && RETRIABLE_NETWORK_ERROR_CODES.has(code)) {
+      return true;
+    }
+
+    const message = candidate.message.toLowerCase();
+    if (RETRIABLE_NETWORK_ERROR_MESSAGES.some((signal) => message.includes(signal))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Check whether an HTTP response represents an account-specific error
  * that would benefit from switching to a different account.

package/src/bun-proxy.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createProxyRequestHandler } from "./bun-proxy.js";
+
+function makeProxyRequest(headers?: HeadersInit): Request {
+  const requestHeaders = new Headers(headers);
+  requestHeaders.set("x-proxy-url", "https://api.anthropic.com/v1/messages");
+  requestHeaders.set("content-type", "application/json");
+
+  return new Request("http://127.0.0.1/proxy", {
+    method: "POST",
+    headers: requestHeaders,
+    body: JSON.stringify({ ok: true }),
+  });
+}
+
+describe("createProxyRequestHandler", () => {
+  it("forwards retry requests with keepalive disabled to the upstream fetch", async () => {
+    const upstreamFetch = vi.fn(async (_input, init?: RequestInit) => {
+      expect(init?.keepalive).toBe(false);
+      const forwardedHeaders = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
+      expect(forwardedHeaders.get("connection")).toBe("close");
+      expect(forwardedHeaders.get("x-proxy-disable-keepalive")).toBeNull();
+      return new Response("ok", { status: 200 });
+    });
+    const handler = createProxyRequestHandler({
+      fetchImpl: upstreamFetch as typeof fetch,
+      allowHosts: ["api.anthropic.com"],
+      requestTimeoutMs: 50,
+    });
+
+    const response = await handler(makeProxyRequest({ "x-proxy-disable-keepalive": "true" }));
+
+    await expect(response.text()).resolves.toBe("ok");
+    expect(upstreamFetch).toHaveBeenCalledTimes(1);
+  });
+});

package/src/bun-proxy.ts

@@ -8,6 +8,7 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 600_000;
 const DEFAULT_PARENT_EXIT_CODE = 1;
 const DEFAULT_PARENT_POLL_INTERVAL_MS = 5_000;
 const HEALTH_PATH = "/__health";
+const PROXY_DISABLE_KEEPALIVE_HEADER = "x-proxy-disable-keepalive";
 const DEBUG_ENABLED = process.env.OPENCODE_ANTHROPIC_DEBUG === "1";
 
 interface ProxyRequestHandlerOptions {
@@ -85,11 +86,16 @@ function createDefaultParentWatcherFactory(): ParentWatcherFactory {
     });
 }
 
-function sanitizeForwardHeaders(source: Headers): Headers {
+function sanitizeForwardHeaders(source: Headers, forceFreshConnection = false): Headers {
   const headers = new Headers(source);
-  ["x-proxy-url", "host", "connection", "content-length"].forEach((headerName) => {
+  [PROXY_DISABLE_KEEPALIVE_HEADER, "x-proxy-url", "host", "connection", "content-length"].forEach((headerName) => {
     headers.delete(headerName);
   });
+
+  if (forceFreshConnection) {
+    headers.set("connection", "close");
+  }
+
   return headers;
 }
 
@@ -161,11 +167,13 @@ async function createUpstreamInit(req: Request, signal: AbortSignal): Promise<Re
   const method = req.method || "GET";
   const hasBody = method !== "GET" && method !== "HEAD";
   const bodyText = hasBody ? await req.text() : "";
+  const forceFreshConnection = req.headers.get(PROXY_DISABLE_KEEPALIVE_HEADER) === "true";
 
   return {
     method,
-    headers: sanitizeForwardHeaders(req.headers),
+    headers: sanitizeForwardHeaders(req.headers, forceFreshConnection),
     signal,
+    ...(forceFreshConnection ? { keepalive: false } : {}),
     ...(hasBody && bodyText.length > 0 ? { body: bodyText } : {}),
   };
 }

package/src/index.ts

@@ -518,12 +518,40 @@ export async function AnthropicAuthPlugin({
 
                 let response: Response;
                 const fetchInput = requestInput as string | URL | Request;
-                try {
-                  response = await fetchWithTransport(fetchInput, {
+                const buildTransportRequestInit = (
+                  headers: Headers,
+                  requestBody: RequestInit["body"],
+                  forceFreshConnection: boolean,
+                ): RequestInit => {
+                  const requestHeadersForTransport = new Headers(headers);
+                  if (forceFreshConnection) {
+                    requestHeadersForTransport.set("connection", "close");
+                    requestHeadersForTransport.set("x-proxy-disable-keepalive", "true");
+                  } else {
+                    requestHeadersForTransport.delete("connection");
+                    requestHeadersForTransport.delete("x-proxy-disable-keepalive");
+                  }
+
+                  return {
                     ...requestInit,
-                    body,
-                    headers: requestHeaders,
-                  });
+                    body: requestBody,
+                    headers: requestHeadersForTransport,
+                    ...(forceFreshConnection ? { keepalive: false } : {}),
+                  };
+                };
+
+                try {
+                  response = await fetchWithRetry(
+                    async ({ forceFreshConnection }) =>
+                      fetchWithTransport(
+                        fetchInput,
+                        buildTransportRequestInit(requestHeaders, body, forceFreshConnection),
+                      ),
+                    {
+                      maxRetries: 2,
+                      shouldRetryResponse: () => false,
+                    },
+                  );
                 } catch (err) {
                   const fetchError = err instanceof Error ? err : new Error(String(err));
                   if (accountManager && account) {
@@ -582,7 +610,7 @@ export async function AnthropicAuthPlugin({
 
                     let retryCount = 0;
                     const retried = await fetchWithRetry(
-                      async () => {
+                      async ({ forceFreshConnection }) => {
                         if (retryCount === 0) {
                           retryCount += 1;
                           return response;
@@ -596,11 +624,10 @@ export async function AnthropicAuthPlugin({
                           requestContext.preparedBody === undefined
                             ? undefined
                             : cloneBodyForRetry(requestContext.preparedBody);
-                        return fetchWithTransport(retryUrl, {
-                          ...requestInit,
-                          body: retryBody,
-                          headers: headersForRetry,
-                        });
+                        return fetchWithTransport(
+                          retryUrl,
+                          buildTransportRequestInit(headersForRetry, retryBody, forceFreshConnection),
+                        );
                       },
                       { maxRetries: 2 },
                     );

package/src/request/retry.test.ts

@@ -149,4 +149,31 @@ describe("fetchWithRetry", () => {
     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,4 +1,9 @@
-import { parseRetryAfterHeader, parseRetryAfterMsHeader, parseShouldRetryHeader } from "../backoff.js";
+import {
+  isRetriableNetworkError,
+  parseRetryAfterHeader,
+  parseRetryAfterMsHeader,
+  parseShouldRetryHeader,
+} from "../backoff.js";
 
 export interface RetryConfig {
   maxRetries: number;
@@ -7,6 +12,16 @@ export interface RetryConfig {
   jitterFraction: number;
 }
 
+export interface RetryAttemptContext {
+  attempt: number;
+  forceFreshConnection: boolean;
+}
+
+export interface RetryOptions extends Partial<RetryConfig> {
+  shouldRetryError?: (error: unknown) => boolean;
+  shouldRetryResponse?: (response: Response) => boolean;
+}
+
 const DEFAULT_RETRY_CONFIG: RetryConfig = {
   maxRetries: 2,
   initialDelayMs: 500,
@@ -31,22 +46,41 @@ export function shouldRetryStatus(status: number, shouldRetryHeader: boolean | n
 }
 
 export async function fetchWithRetry(
-  doFetch: () => Promise<Response>,
-  config: Partial<RetryConfig> = {},
+  doFetch: (context: RetryAttemptContext) => Promise<Response>,
+  options: RetryOptions = {},
 ): Promise<Response> {
-  const resolvedConfig: RetryConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  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++) {
-    const response = await doFetch();
+    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;
     }
 
-    const shouldRetryHeader = parseShouldRetryHeader(response);
-    const shouldRetry = shouldRetryStatus(response.status, shouldRetryHeader);
-
-    if (!shouldRetry || attempt >= resolvedConfig.maxRetries) {
+    if (!shouldRetryResponse(response) || attempt >= resolvedConfig.maxRetries) {
       return response;
     }
 
@@ -56,5 +90,6 @@ export async function fetchWithRetry(
       calculateRetryDelay(attempt, resolvedConfig);
 
     await waitFor(delayMs);
+    forceFreshConnection = false;
   }
 }