Function fetchAndReadBody

src/cache.ts:597–648

(
  url: RequestInfo,
  options: RequestInit,
  timeout: number,
  maxRetries: number | undefined,
  isIdempotent: boolean,
)

}

async function fetchAndReadBody(
  url: RequestInfo,
  options: RequestInit,
  timeout: number,
  maxRetries: number | undefined,
  isIdempotent: boolean,
): Promise<{ respText: string; resp: Response; fetchLatencyMs: number }> {
  const maxBodyRetries = isIdempotent ? 2 : 0;
  for (let bodyAttempt = 0; bodyAttempt <= maxBodyRetries; bodyAttempt++) {
    const fetchStart = Date.now();
    // fetchWithRetries errors propagate directly — not caught by body retry
    const resp = await fetchWithRetries(url, options, timeout, maxRetries);
    const fetchLatencyMs = Date.now() - fetchStart;

    try {
      const respText = await resp.text();
      return { respText, resp, fetchLatencyMs };
    } catch (err) {
      if (isTransientConnectionError(err as Error) && bodyAttempt < maxBodyRetries) {
        const backoffMs = Math.pow(2, bodyAttempt) * 1000;
        logger.debug('[Cache] Body stream failed with transient error, retrying', {
          attempt: bodyAttempt + 1,
          maxRetries: maxBodyRetries,
          backoffMs,
          error: (err as Error)?.message?.slice(0, 200),
        });
        await sleep(backoffMs);
        continue;
      }
      // Preserve cancellation: an aborted body read rejects with an AbortError, and
      // callers (e.g. evaluator.ts) suppress expected cancellation by checking
      // `err.name === 'AbortError'`. Wrapping it would reset the name to 'Error' and
      // turn cancelled evals into ordinary provider failures, so rethrow aborts as-is.
      if (isAbortError(err)) {
        throw err;
      }
      // Surface the URL and HTTP response context so opaque body-read failures
      // (e.g. "TypeError: terminated" from a Cloudflare-originated 403) include
      // actionable diagnostics instead of a bare platform error. Sanitize the URL so
      // credential-bearing userinfo / query params are not leaked into logs.
      const wrappedError = new Error(
        `Error reading response body from ${sanitizeUrl(getRequestUrlString(url))}: ${
          (err as Error).message
        }. HTTP ${resp.status} ${resp.statusText}`,
      ) as Error & { cause?: unknown };
      wrappedError.cause = err;
      throw wrappedError;
    }
  }
  // Unreachable: loop always returns or throws, but TypeScript needs this
  throw new Error('Exhausted body retries without returning or throwing');
}

async function prepareFetchResponse(
  url: RequestInfo,