Function with_retry

crates/opencode-provider/src/retry.rs:145–178

Retry an async operation up to `config.max_attempts` times. The closure `f` is called on each attempt. If it returns `Err(e)` and `e.is_retryable()` returns `Some(_)`, the helper sleeps for the computed delay and tries again. Otherwise the error is returned immediately.

(config: &RetryConfig, mut f: F)

/// `e.is_retryable()` returns `Some(_)`, the helper sleeps for the computed
/// delay and tries again. Otherwise the error is returned immediately.
pub async fn with_retry<F, Fut, T, E>(config: &RetryConfig, mut f: F) -> Result<T, E>
where
    F: FnMut() -> Fut,
    Fut: Future<Output = Result<T, E>>,
    E: IsRetryable + std::fmt::Debug,
{
    let mut attempt: u32 = 0;

    loop {
        attempt += 1;
        match f().await {
            Ok(val) => return Ok(val),
            Err(e) => {
                if attempt >= config.max_attempts {
                    return Err(e);
                }
                match e.is_retryable() {
                    Some(msg) => {
                        let delay_ms = delay(attempt, None);
                        warn!(
                            attempt,
                            max = config.max_attempts,
                            delay_ms,
                            reason = %msg,
                            "retrying after transient error"
                        );
                        tokio::time::sleep(std::time::Duration::from_millis(delay_ms)).await;
                    }
                    None => return Err(e),
                }
            }
        }
    }
}

/// Same as [`with_retry`] but calls `hook(attempt, &error, delay_ms)` before
/// each retry sleep, giving the caller a chance to log or update UI.