Function with_retry

core/src/retry.rs:131–184

Execute an async operation with retry logic. The `operation` closure is called on each attempt and must return an `AttemptOutcome`. On retryable failures, waits with exponential backoff before retrying. On fatal failures or after exhausting retries, returns an error.

(config: &RetryConfig, operation: F)

/// On retryable failures, waits with exponential backoff before retrying.
/// On fatal failures or after exhausting retries, returns an error.
pub async fn with_retry<T, F, Fut>(config: &RetryConfig, operation: F) -> anyhow::Result<T>
where
    F: Fn(u32) -> Fut,
    Fut: std::future::Future<Output = AttemptOutcome<T>>,
{
    let mut last_status = None;
    let mut last_body = String::new();

    for attempt in 0..=config.max_retries {
        match operation(attempt).await {
            AttemptOutcome::Success(value) => {
                if attempt > 0 {
                    tracing::info!("LLM API request succeeded after {} retries", attempt);
                }
                return Ok(value);
            }
            AttemptOutcome::Fatal(err) => {
                return Err(err);
            }
            AttemptOutcome::Retryable {
                status,
                body,
                retry_after,
            } => {
                last_status = Some(status);
                last_body = body;

                if attempt < config.max_retries {
                    // Determine delay: prefer Retry-After header, fallback to exponential backoff
                    let delay = retry_after.unwrap_or_else(|| config.delay_for_attempt(attempt));

                    tracing::warn!(
                        "LLM API request failed with {} (attempt {}/{}), retrying in {:?}",
                        status,
                        attempt + 1,
                        config.max_retries + 1,
                        delay,
                    );

                    tokio::time::sleep(delay).await;
                }
            }
        }
    }

    // All retries exhausted
    let status = last_status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
    anyhow::bail!(
        "LLM API request failed after {} attempts. Last status: {} Body: {}",
        config.max_retries + 1,
        status,
        last_body,
    )
}

/// Heuristic: is this a transient *network* error worth retrying — a timeout,
/// connection reset/refused/closed, broken pipe, DNS failure, or a request that