Function withRetry

src/utils/retry.ts:122–167

(fn: (attempt: number) => Promise<T>, opts: RetryOptions = {})

 * permanent). The first attempt has attempt index 0.
 */
export async function withRetry<T>(fn: (attempt: number) => Promise<T>, opts: RetryOptions = {}): Promise<T> {
  const maxAttempts = opts.maxAttempts ?? 4;
  const baseMs = opts.baseMs ?? 400;
  const capMs = opts.capMs ?? 8000;
  const retryable = opts.isRetryable ?? isTransientError;
  const maxRetryAfterMs = opts.maxRetryAfterMs ?? 60_000;
  const label = opts.label ?? 'op';

  let lastErr: unknown;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    if (opts.signal?.aborted) throw new Error('aborted');
    try {
      return await fn(attempt);
    } catch (err) {
      lastErr = err;
      const isLast = attempt === maxAttempts - 1;
      if (isLast || !retryable(err)) throw err;

      // Compute wait: prefer server's Retry-After, else full-jitter backoff.
      const server = retryAfterMs(err);
      // A Retry-After longer than we're willing to block (e.g. a daily quota
      // 429 asking for many minutes) → fail fast instead of hanging the turn.
      if (server !== undefined && server > maxRetryAfterMs) {
        logger.warn(`Retry ${label}: server Retry-After ${Math.round(server / 1000)}s exceeds cap ${Math.round(maxRetryAfterMs / 1000)}s — giving up (switch model/provider)`, {
          status: statusOf(err),
        });
        throw err;
      }
      const expo = Math.min(capMs, baseMs * 2 ** attempt);
      const wait = server ?? Math.floor(Math.random() * expo);
      logger.warn(`Retry ${label}`, {
        attempt: attempt + 1,
        maxAttempts,
        waitMs: wait,
        status: statusOf(err),
        err: String((err as any)?.message ?? err).slice(0, 160),
      });
      try {
        await abortableSleep(wait, opts.signal);
      } catch {
        throw err; // aborted during backoff → surface the original error
      }
    }
  }
  throw lastErr;
}