Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_attempts: u32,
    pub base_delay: Duration,
    pub kind: RetryKind,
}

Configurable retry policy with exponential backoff or constant interval.

Fields

max_attempts: u32

Maximum number of attempts (including the first).

base_delay: Duration

Base delay for the first retry.

kind: RetryKind

Whether to use exponential or constant delay.

Implementations

impl RetryPolicy

pub fn exponential( max_attempts: u32, base_ms: u64, ) -> Result<Self, AgentRuntimeError>

Create an exponential retry policy.

Arguments

• max_attempts — total attempt budget (must be ≥ 1)
• base_ms — base delay in milliseconds for attempt 1

Returns

• Ok(RetryPolicy) — on success
• Err(AgentRuntimeError::Orchestration) — if max_attempts == 0

pub fn constant( max_attempts: u32, delay_ms: u64, ) -> Result<Self, AgentRuntimeError>

Create a constant (fixed-interval) retry policy.

Every retry waits exactly delay_ms milliseconds regardless of attempt number, unlike exponential which doubles the delay each time.

Returns

• Ok(RetryPolicy) — on success
• Err(AgentRuntimeError::Orchestration) — if max_attempts == 0 or delay_ms == 0

pub fn none() -> Self

Create a no-retry policy (single attempt, no delay).

Useful for one-shot operations or when the caller manages retry logic externally.

pub fn is_none(&self) -> bool

Return true if this policy makes at most one attempt with no delay.

Equivalent to max_attempts == 1 && base_delay == Duration::ZERO.

pub fn with_max_attempts(self, n: u32) -> Result<Self, AgentRuntimeError>

Return a copy of this policy with max_attempts changed.

Errors

Returns Err if n == 0.

pub fn max_attempts(&self) -> u32

Return the configured maximum number of attempts.

pub fn is_no_retry(&self) -> bool

Return true if this policy performs no retries (max_attempts ≤ 1).

Useful for short-circuiting retry logic in hot paths.

pub fn will_retry_at_all(&self) -> bool

Return true if this policy allows at least one retry (max_attempts > 1).

Complement of is_no_retry.

pub fn is_exponential(&self) -> bool

Return true if this policy uses exponential back-off between retries.

pub fn is_constant(&self) -> bool

Return true if this policy uses a constant (fixed-interval) delay between retries.

pub fn base_delay_ms(&self) -> u64

Return the configured base delay in milliseconds.

For constant policies this equals every per-retry delay. For exponential policies this is the delay before the first retry.

pub fn first_delay_ms(&self) -> u64

Return the delay before the first retry in milliseconds.

Alias for base_delay_ms; the name communicates intent more clearly at call sites that only care about the first-retry delay.

pub fn is_last_attempt(&self, attempt: u32) -> bool

Return true if attempt is the last allowed attempt for this policy.

attempt is 1-indexed: attempt == max_attempts means no more retries.

pub fn max_total_delay_ms(&self) -> u64

Return the sum of all per-attempt delays across all attempts, in milliseconds.

For exponential policies each attempt’s delay is capped at MAX_RETRY_DELAY. For constant policies every attempt uses base_delay_ms.

pub fn delay_sum_ms(&self, n: u32) -> u64

Return the sum of delays for the first n attempts, in milliseconds.

If n > max_attempts, only max_attempts delays are summed.

pub fn avg_delay_ms(&self) -> u64

Return the average delay per attempt in milliseconds.

Returns 0 for policies with no delay (e.g. RetryPolicy::none()).

pub fn backoff_factor(&self) -> f64

Return the effective backoff factor per attempt.

Returns 2.0 for exponential policies and 1.0 for constant policies.

pub fn with_base_delay_ms(self, ms: u64) -> Result<Self, AgentRuntimeError>

Return a copy of this policy with the base delay changed to ms milliseconds.

Errors

Returns Err if ms == 0.

pub fn delay_ms_for(&self, attempt: u32) -> u64

Return the delay for attempt in whole milliseconds.

Convenience wrapper around delay_for for use in logging and metrics where a u64 is easier to handle than a Duration.

pub fn total_max_delay_ms(&self) -> u64

Return the total maximum delay in milliseconds across all retry attempts.

Sums delay_for(attempt) for every attempt from 1 to max_attempts. Useful for estimating worst-case latency budgets.

pub fn attempts_remaining(&self, attempt: u32) -> u32

Return the number of attempts still available after attempt have been made.

Returns 0 once the budget is exhausted (attempt >= max_attempts).

pub fn attempts_budget_used(&self, attempt: u32) -> f64

Return the fraction of the retry budget consumed after attempt attempts.

Computed as attempt / max_attempts, clamped to [0.0, 1.0]. Returns 1.0 when max_attempts is zero (budget fully consumed by definition).

Useful for surfacing “how far through the retry budget are we” in dashboards and progress logs.

pub fn max_delay_ms(&self) -> u64

Return the maximum delay for any single attempt in milliseconds.

For Exponential policies this is the delay for the last attempt (which may be capped by MAX_RETRY_DELAY). For Constant policies it equals the base delay. Returns 0 for a none() policy.

pub fn can_retry(&self, attempt: u32) -> bool

Return true if another attempt is permitted after attempt failures.

attempt is the number of attempts already made (0-based: 0 means no attempt has been made yet). Returns false once the budget is exhausted (i.e. attempt >= max_attempts).

pub fn delay_for(&self, attempt: u32) -> Duration

Compute the delay before the given attempt number (1-based).

• RetryKind::Exponential: base_delay * 2^(attempt-1), capped at MAX_RETRY_DELAY.
• RetryKind::Constant: always returns base_delay.

pub fn is_bounded(&self) -> bool

Return true if the policy has a finite retry limit.

A policy with max_attempts < u32::MAX is considered bounded. In practice all policies created via the public constructors are bounded.

pub fn remaining_wait_budget_ms(&self, attempts_done: u32) -> u64

Return the remaining wait budget in milliseconds after attempts_done have been completed.

Computed as max_total_delay_ms().saturating_sub(delay_sum_ms(attempts_done)). Returns 0 when attempts_done equals or exceeds max_attempts.

pub fn max_single_delay_ms(&self) -> u64

Return the maximum delay a single retry attempt can incur, in milliseconds.

For exponential policies this is delay_for(max_attempts) which equals base * 2^(max_attempts-1) capped at the global MAX_RETRY_DELAY. For constant policies this equals the configured base delay.

pub fn covers_n_failures(&self, n: u32) -> bool

Return true if this policy allows at least n retry attempts (i.e. max_attempts > n).

Useful for validating that a policy can tolerate a minimum number of consecutive failures before giving up.

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.

impl Display for RetryPolicy

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

Render as "Exponential(n×, base=Xms)" or "Constant(n×, delay=Xms)".