Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_attempts: usize,
    pub strategy: RetryStrategy,
}

Configuration for automatic retry behaviour with backoff.

Construct via the factory helpers RetryPolicy::fixed, RetryPolicy::exponential, or RetryPolicy::linear, then execute an async closure with RetryPolicy::retry.

Examples

use std::time::Duration;
use tokio_prompt_orchestrator::enhanced::RetryPolicy;

let policy = RetryPolicy::exponential(3, Duration::from_millis(100));

let result: Result<String, String> = policy.retry(|| async {
    // replace with a real async call
    Err("transient".to_string())
}).await;

// All 3 attempts failed
assert!(result.is_err());

Fields

max_attempts: usize

Maximum number of attempts (including the first try).

strategy: RetryStrategy

Backoff strategy applied between consecutive attempts.

Implementations

impl RetryPolicy

pub fn fixed(max_attempts: usize, delay: Duration) -> Self

Create a policy that waits a constant delay between attempts.

Arguments

• max_attempts — Total attempts including the first try. 1 means no retries.
• delay — Fixed pause between consecutive attempts.

Examples

use std::time::Duration;
use tokio_prompt_orchestrator::enhanced::RetryPolicy;

let policy = RetryPolicy::fixed(3, Duration::from_millis(50));
assert_eq!(policy.max_attempts, 3);

pub fn exponential(max_attempts: usize, initial_delay: Duration) -> Self

Create a policy with exponential back-off (multiplier 2×, cap 60 s).

The delay before attempt n is: min(initial_delay × 2^(n-1), 60 s)

Arguments

• max_attempts — Total attempts including the first try.
• initial_delay — Delay before the second attempt.

Examples

use std::time::Duration;
use tokio_prompt_orchestrator::enhanced::RetryPolicy;

// Delays: 100 ms, 200 ms, 400 ms
let policy = RetryPolicy::exponential(4, Duration::from_millis(100));

pub fn linear( max_attempts: usize, initial_delay: Duration, increment: Duration, ) -> Self

Create policy with linear backoff

pub async fn retry<F, Fut, T, E>(&self, f: F) -> Result<T, E>

where F: FnMut() -> Fut, Fut: Future<Output = Result<T, E>>, E: Display,

Execute a fallible async closure, retrying on error according to this policy.

The closure f is called up to max_attempts times. Between consecutive failures the task sleeps for the duration computed by the configured RetryStrategy.

Arguments

• f — A FnMut that returns a Future<Output = Result<T, E>>.

Returns

Ok(value) from the first successful attempt, or Err(last_error) if all attempts fail.

Examples

use std::time::Duration;
use tokio_prompt_orchestrator::enhanced::RetryPolicy;

let policy = RetryPolicy::fixed(3, Duration::from_millis(10));
let result: Result<&str, &str> = policy.retry(|| async { Ok("done") }).await;
assert_eq!(result, Ok("done"));

pub async fn retry_with_details<F, Fut, T, E>(&self, f: F) -> RetryResult<T, E>

where F: FnMut() -> Fut, Fut: Future<Output = Result<T, E>>, E: Display,

Execute with retries, returning detailed result

pub fn is_retryable<E>(&self, _error: &E) -> bool

Check if error is retryable (can be customized)

Trait Implementations

impl Clone for RetryPolicy

fn clone(&self) -> RetryPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RetryPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.