use std::time::{Duration, Instant};
pub const DEFAULT_MAX_MODEL_STEPS: u32 = u32::MAX;
pub const DEFAULT_TURN_WALL_CLOCK: Duration = Duration::MAX;
pub const DEFAULT_STREAM_MAX_CONTENT_BYTES: usize = 10 * 1024 * 1024;
pub const MIN_STREAM_MAX_CONTENT_BYTES: usize = 64 * 1024;
pub const MAX_STREAM_MAX_CONTENT_BYTES: usize = 512 * 1024 * 1024;
pub const DEFAULT_STREAM_MAX_DURATION_SECS: u64 = 1800;
pub const MIN_STREAM_MAX_DURATION_SECS: u64 = 10;
pub const MAX_STREAM_MAX_DURATION_SECS: u64 = 86_400;
pub const DEFAULT_STREAM_MAX_RESUMES: u32 = 3;
pub const MAX_STREAM_MAX_RESUMES: u32 = 10;
pub const DEFAULT_STREAM_MAX_TRANSPARENT_RETRIES: u32 = 2;
pub const MAX_STREAM_MAX_TRANSPARENT_RETRIES: u32 = 10;
pub const DEFAULT_STREAM_MAX_ERRORS: u32 = 5;
pub const MIN_STREAM_MAX_ERRORS: u32 = 1;
pub const MAX_STREAM_MAX_ERRORS: u32 = 50;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StreamRetryLimits {
pub max_resumes: u32,
pub max_transparent_retries: u32,
pub max_errors: u32,
}
impl Default for StreamRetryLimits {
fn default() -> Self {
resolve_stream_retry_limits(None, None, None)
}
}
#[must_use]
pub fn resolve_stream_retry_limits(
max_resumes: Option<u32>,
max_transparent_retries: Option<u32>,
max_errors: Option<u32>,
) -> StreamRetryLimits {
StreamRetryLimits {
max_resumes: max_resumes
.unwrap_or(DEFAULT_STREAM_MAX_RESUMES)
.min(MAX_STREAM_MAX_RESUMES),
max_transparent_retries: max_transparent_retries
.unwrap_or(DEFAULT_STREAM_MAX_TRANSPARENT_RETRIES)
.min(MAX_STREAM_MAX_TRANSPARENT_RETRIES),
max_errors: match max_errors {
None | Some(0) => DEFAULT_STREAM_MAX_ERRORS,
Some(value) => value.clamp(MIN_STREAM_MAX_ERRORS, MAX_STREAM_MAX_ERRORS),
},
}
}
#[must_use]
pub fn resolve_max_model_steps(raw: Option<u32>) -> u32 {
match raw {
None | Some(0) => DEFAULT_MAX_MODEL_STEPS,
Some(value) => value,
}
}
#[must_use]
pub fn resolve_turn_wall_clock(raw: Option<u64>) -> Duration {
match raw {
None | Some(0) => DEFAULT_TURN_WALL_CLOCK,
Some(value) => Duration::from_secs(value),
}
}
#[must_use]
pub fn resolve_stream_max_content_bytes(raw_mb: Option<u64>) -> usize {
match raw_mb {
None | Some(0) => DEFAULT_STREAM_MAX_CONTENT_BYTES,
Some(mb) => usize::try_from(mb.saturating_mul(1024 * 1024))
.unwrap_or(MAX_STREAM_MAX_CONTENT_BYTES)
.clamp(MIN_STREAM_MAX_CONTENT_BYTES, MAX_STREAM_MAX_CONTENT_BYTES),
}
}
#[must_use]
pub fn resolve_stream_max_duration_secs(raw: Option<u64>) -> u64 {
match raw {
None | Some(0) => DEFAULT_STREAM_MAX_DURATION_SECS,
Some(value) => value.clamp(MIN_STREAM_MAX_DURATION_SECS, MAX_STREAM_MAX_DURATION_SECS),
}
}
#[derive(Debug)]
pub struct TurnWallClock {
budget: Duration,
started_at: Instant,
excluded: Duration,
blocked_since: Option<Instant>,
}
impl TurnWallClock {
pub fn start(budget: Duration) -> Self {
Self {
budget,
started_at: Instant::now(),
excluded: Duration::ZERO,
blocked_since: None,
}
}
pub fn budget(&self) -> Duration {
self.budget
}
pub fn spent(&self) -> Duration {
let blocked_now = self
.blocked_since
.map_or(Duration::ZERO, |since| since.elapsed());
self.started_at
.elapsed()
.saturating_sub(self.excluded)
.saturating_sub(blocked_now)
}
pub fn exhausted(&self) -> bool {
self.spent() >= self.budget
}
pub fn begin_human_wait(&mut self) {
if self.blocked_since.is_none() {
self.blocked_since = Some(Instant::now());
}
}
pub fn end_human_wait(&mut self) {
if let Some(since) = self.blocked_since.take() {
self.excluded = self.excluded.saturating_add(since.elapsed());
}
}
#[cfg(any(test, feature = "test-support"))]
pub fn rewind_for_test(&mut self, elapsed: Duration) {
self.started_at = self
.started_at
.checked_sub(elapsed)
.unwrap_or(self.started_at);
if let Some(since) = self.blocked_since {
self.blocked_since = Some(since.checked_sub(elapsed).unwrap_or(since));
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn model_step_defaults_do_not_install_a_ceiling() {
assert_eq!(resolve_max_model_steps(None), DEFAULT_MAX_MODEL_STEPS);
assert_eq!(resolve_max_model_steps(Some(0)), DEFAULT_MAX_MODEL_STEPS);
assert_eq!(DEFAULT_MAX_MODEL_STEPS, u32::MAX);
assert_eq!(resolve_max_model_steps(Some(u32::MAX)), u32::MAX);
}
#[test]
fn model_step_ceiling_preserves_the_owner_limit() {
assert_eq!(resolve_max_model_steps(Some(7)), 7);
assert_eq!(resolve_max_model_steps(Some(1)), 1);
assert_eq!(
resolve_max_model_steps(Some(200_000)),
200_000,
"explicit positive overrides retain the configured ceiling"
);
}
#[test]
fn turn_wall_clock_defaults_to_no_limit() {
assert_eq!(resolve_turn_wall_clock(None), DEFAULT_TURN_WALL_CLOCK);
assert_eq!(resolve_turn_wall_clock(Some(0)), DEFAULT_TURN_WALL_CLOCK);
let mut clock = TurnWallClock::start(resolve_turn_wall_clock(None));
clock.rewind_for_test(Duration::from_secs(10 * 24 * 60 * 60));
assert!(!clock.exhausted(), "the default never stops a turn");
}
#[tokio::test]
async fn an_unbounded_remaining_budget_is_a_safe_sleep() {
let remaining = DEFAULT_TURN_WALL_CLOCK.saturating_sub(Duration::from_secs(1));
let woke =
tokio::time::timeout(Duration::from_millis(20), tokio::time::sleep(remaining)).await;
assert!(woke.is_err(), "the sleep parks until cancelled");
let started = std::time::Instant::now();
assert!(started.checked_add(remaining).is_none());
}
#[test]
fn turn_wall_clock_preserves_the_owner_limit() {
assert_eq!(resolve_turn_wall_clock(Some(120)), Duration::from_secs(120));
assert_eq!(resolve_turn_wall_clock(Some(1)), Duration::from_secs(1));
assert_eq!(
resolve_turn_wall_clock(Some(u64::MAX)),
Duration::from_secs(u64::MAX)
);
}
#[test]
fn stream_caps_default_reject_zero_and_are_overridable() {
assert_eq!(
resolve_stream_max_content_bytes(None),
DEFAULT_STREAM_MAX_CONTENT_BYTES
);
assert_eq!(
resolve_stream_max_content_bytes(Some(0)),
DEFAULT_STREAM_MAX_CONTENT_BYTES
);
assert_eq!(resolve_stream_max_content_bytes(Some(1)), 1024 * 1024);
assert_eq!(
resolve_stream_max_content_bytes(Some(u64::MAX)),
MAX_STREAM_MAX_CONTENT_BYTES
);
assert_eq!(
resolve_stream_max_duration_secs(None),
DEFAULT_STREAM_MAX_DURATION_SECS
);
assert_eq!(
resolve_stream_max_duration_secs(Some(0)),
DEFAULT_STREAM_MAX_DURATION_SECS
);
assert_eq!(resolve_stream_max_duration_secs(Some(60)), 60);
assert_eq!(
resolve_stream_max_duration_secs(Some(u64::MAX)),
MAX_STREAM_MAX_DURATION_SECS
);
}
#[test]
fn stream_retry_limits_default_to_historical_values_and_clamp() {
let defaults = resolve_stream_retry_limits(None, None, None);
assert_eq!(defaults, StreamRetryLimits::default());
assert_eq!(defaults.max_resumes, 3);
assert_eq!(defaults.max_transparent_retries, 2);
assert_eq!(defaults.max_errors, 5);
let disabled = resolve_stream_retry_limits(Some(0), Some(0), Some(0));
assert_eq!(disabled.max_resumes, 0, "0 disables resumes");
assert_eq!(disabled.max_transparent_retries, 0);
assert_eq!(
disabled.max_errors, DEFAULT_STREAM_MAX_ERRORS,
"0 selects the error-streak default, like the other finite stream budgets"
);
assert_eq!(
resolve_stream_retry_limits(None, None, Some(1)).max_errors,
MIN_STREAM_MAX_ERRORS
);
let huge = resolve_stream_retry_limits(Some(u32::MAX), Some(u32::MAX), Some(u32::MAX));
assert_eq!(huge.max_resumes, MAX_STREAM_MAX_RESUMES);
assert_eq!(
huge.max_transparent_retries,
MAX_STREAM_MAX_TRANSPARENT_RETRIES
);
assert_eq!(huge.max_errors, MAX_STREAM_MAX_ERRORS);
}
#[test]
fn wall_clock_exhausts_once_the_budget_is_spent() {
let mut clock = TurnWallClock::start(Duration::from_secs(60));
assert!(!clock.exhausted());
clock.rewind_for_test(Duration::from_secs(61));
assert!(clock.exhausted());
assert!(clock.spent() >= clock.budget());
}
#[test]
fn wall_clock_excludes_time_blocked_on_a_human_decision() {
let mut clock = TurnWallClock::start(Duration::from_secs(60));
clock.begin_human_wait();
clock.rewind_for_test(Duration::from_secs(120));
assert!(
!clock.exhausted(),
"an unanswered approval prompt must not burn the turn budget"
);
clock.end_human_wait();
assert!(!clock.exhausted());
clock.rewind_for_test(Duration::from_secs(61));
assert!(clock.exhausted());
}
#[test]
fn nested_human_waits_cannot_double_exclude() {
let mut clock = TurnWallClock::start(Duration::from_secs(60));
clock.begin_human_wait();
clock.begin_human_wait();
clock.rewind_for_test(Duration::from_secs(30));
clock.end_human_wait();
clock.end_human_wait();
clock.rewind_for_test(Duration::from_secs(61));
assert!(clock.exhausted());
}
}