An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
feat: b5-slash-help — batch 5 upstream parity
YeonGyu-Kim5bcbc86a2b43
diff --git a/rust/crates/api/src/providers/anthropic.rs b/rust/crates/api/src/providers/anthropic.rsindex fb2b3169..31801690 100644--- a/rust/crates/api/src/providers/anthropic.rs+++ b/rust/crates/api/src/providers/anthropic.rs@@ -1,4 +1,5 @@use std::collections::VecDeque;+use std::sync::atomic::{AtomicU64, Ordering};use std::sync::{Arc, Mutex};use std::time::{Duration, SystemTime, UNIX_EPOCH};@@ -22,9 +23,9 @@ use crate::types::{MessageDeltaEvent, MessageRequest, MessageResponse, StreamEvepub const DEFAULT_BASE_URL: &str = "https://api.anthropic.com";const REQUEST_ID_HEADER: &str = "request-id";const ALT_REQUEST_ID_HEADER: &str = "x-request-id";-const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_millis(200);-const DEFAULT_MAX_BACKOFF: Duration = Duration::from_secs(2);-const DEFAULT_MAX_RETRIES: u32 = 2;+const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_secs(1);+const DEFAULT_MAX_BACKOFF: Duration = Duration::from_secs(128);+const DEFAULT_MAX_RETRIES: u32 = 8;#[derive(Debug, Clone, PartialEq, Eq)]pub enum AuthSource {@@ -453,7 +454,7 @@ impl AnthropicClient {break;}- tokio::time::sleep(self.backoff_for_attempt(attempts)?).await;+ tokio::time::sleep(self.jittered_backoff_for_attempt(attempts)?).await;}Err(ApiError::RetriesExhausted {@@ -569,6 +570,40 @@ impl AnthropicClient {.checked_mul(multiplier).map_or(self.max_backoff, |delay| delay.min(self.max_backoff)))}++ fn jittered_backoff_for_attempt(&self, attempt: u32) -> Result<Duration, ApiError> {+ let base = self.backoff_for_attempt(attempt)?;+ Ok(base + jitter_for_base(base))+ }+}++/// Process-wide counter that guarantees distinct jitter samples even when+/// the system clock resolution is coarser than consecutive retry sleeps.+static JITTER_COUNTER: AtomicU64 = AtomicU64::new(0);++/// Returns a random additive jitter in `[0, base]` to decorrelate retries+/// from multiple concurrent clients. Entropy is drawn from the nanosecond+/// wall clock mixed with a monotonic counter and run through a splitmix64+/// finalizer; adequate for retry jitter (no cryptographic requirement).+fn jitter_for_base(base: Duration) -> Duration {+ let base_nanos = u64::try_from(base.as_nanos()).unwrap_or(u64::MAX);+ if base_nanos == 0 {+ return Duration::ZERO;+ }+ let raw_nanos = SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .map(|elapsed| u64::try_from(elapsed.as_nanos()).unwrap_or(u64::MAX))+ .unwrap_or(0);+ let tick = JITTER_COUNTER.fetch_add(1, Ordering::Relaxed);+ // splitmix64 finalizer — mixes the low bits so large bases still see+ // jitter across their full range instead of being clamped to subsec nanos.+ let mut mixed = raw_nanos.wrapping_add(tick).wrapping_add(0x9E37_79B9_7F4A_7C15);+ mixed = (mixed ^ (mixed >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);+ mixed = (mixed ^ (mixed >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);+ mixed ^= mixed >> 31;+ // Inclusive upper bound: jitter may equal `base`, matching "up to base".+ let jitter_nanos = mixed % base_nanos.saturating_add(1);+ Duration::from_nanos(jitter_nanos)}impl AuthSource {@@ -1250,6 +1285,58 @@ mod tests {);}+ #[test]+ fn jittered_backoff_stays_within_additive_bounds_and_varies() {+ let client = AnthropicClient::new("test-key").with_retry_policy(+ 8,+ Duration::from_secs(1),+ Duration::from_secs(128),+ );+ let mut samples = Vec::with_capacity(64);+ for _ in 0..64 {+ let base = client.backoff_for_attempt(3).expect("base attempt 3");+ let jittered = client+ .jittered_backoff_for_attempt(3)+ .expect("jittered attempt 3");+ assert!(+ jittered >= base,+ "jittered delay {jittered:?} must be at least the base {base:?}"+ );+ assert!(+ jittered <= base * 2,+ "jittered delay {jittered:?} must not exceed base*2 {:?}",+ base * 2+ );+ samples.push(jittered);+ }+ let distinct: std::collections::HashSet<_> = samples.iter().collect();+ assert!(+ distinct.len() > 1,+ "jitter should produce varied delays across samples, got {samples:?}"+ );+ }++ #[test]+ fn default_retry_policy_matches_exponential_schedule() {+ let client = AnthropicClient::new("test-key");+ assert_eq!(+ client.backoff_for_attempt(1).expect("attempt 1"),+ Duration::from_secs(1)+ );+ assert_eq!(+ client.backoff_for_attempt(2).expect("attempt 2"),+ Duration::from_secs(2)+ );+ assert_eq!(+ client.backoff_for_attempt(3).expect("attempt 3"),+ Duration::from_secs(4)+ );+ assert_eq!(+ client.backoff_for_attempt(8).expect("attempt 8"),+ Duration::from_secs(128)+ );+ }+#[test]fn retryable_statuses_are_detected() {assert!(super::is_retryable_status(diff --git a/rust/crates/api/src/providers/openai_compat.rs b/rust/crates/api/src/providers/openai_compat.rsindex 0afe4ffc..57d9ef22 100644--- a/rust/crates/api/src/providers/openai_compat.rs+++ b/rust/crates/api/src/providers/openai_compat.rs@@ -1,5 +1,6 @@use std::collections::{BTreeMap, VecDeque};-use std::time::Duration;+use std::sync::atomic::{AtomicU64, Ordering};+use std::time::{Duration, SystemTime, UNIX_EPOCH};use serde::Deserialize;use serde_json::{json, Value};@@ -19,9 +20,9 @@ pub const DEFAULT_XAI_BASE_URL: &str = "https://api.x.ai/v1";pub const DEFAULT_OPENAI_BASE_URL: &str = "https://api.openai.com/v1";const REQUEST_ID_HEADER: &str = "request-id";const ALT_REQUEST_ID_HEADER: &str = "x-request-id";-const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_millis(200);-const DEFAULT_MAX_BACKOFF: Duration = Duration::from_secs(2);-const DEFAULT_MAX_RETRIES: u32 = 2;+const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_secs(1);+const DEFAULT_MAX_BACKOFF: Duration = Duration::from_secs(128);+const DEFAULT_MAX_RETRIES: u32 = 8;#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct OpenAiCompatConfig {@@ -191,7 +192,7 @@ impl OpenAiCompatClient {break retryable_error;}- tokio::time::sleep(self.backoff_for_attempt(attempts)?).await;+ tokio::time::sleep(self.jittered_backoff_for_attempt(attempts)?).await;};Err(ApiError::RetriesExhausted {@@ -227,6 +228,37 @@ impl OpenAiCompatClient {.checked_mul(multiplier).map_or(self.max_backoff, |delay| delay.min(self.max_backoff)))}++ fn jittered_backoff_for_attempt(&self, attempt: u32) -> Result<Duration, ApiError> {+ let base = self.backoff_for_attempt(attempt)?;+ Ok(base + jitter_for_base(base))+ }+}++/// Process-wide counter that guarantees distinct jitter samples even when+/// the system clock resolution is coarser than consecutive retry sleeps.+static JITTER_COUNTER: AtomicU64 = AtomicU64::new(0);++/// Returns a random additive jitter in `[0, base]` to decorrelate retries+/// from multiple concurrent clients. Entropy is drawn from the nanosecond+/// wall clock mixed with a monotonic counter and run through a splitmix64+/// finalizer; adequate for retry jitter (no cryptographic requirement).+fn jitter_for_base(base: Duration) -> Duration {+ let base_nanos = u64::try_from(base.as_nanos()).unwrap_or(u64::MAX);+ if base_nanos == 0 {+ return Duration::ZERO;+ }+ let raw_nanos = SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .map(|elapsed| u64::try_from(elapsed.as_nanos()).unwrap_or(u64::MAX))+ .unwrap_or(0);+ let tick = JITTER_COUNTER.fetch_add(1, Ordering::Relaxed);+ let mut mixed = raw_nanos.wrapping_add(tick).wrapping_add(0x9E37_79B9_7F4A_7C15);+ mixed = (mixed ^ (mixed >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);+ mixed = (mixed ^ (mixed >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);+ mixed ^= mixed >> 31;+ let jitter_nanos = mixed % base_nanos.saturating_add(1);+ Duration::from_nanos(jitter_nanos)}impl Provider for OpenAiCompatClient {diff --git a/rust/crates/api/tests/client_integration.rs b/rust/crates/api/tests/client_integration.rsindex 2f42a79b..9d45cc78 100644--- a/rust/crates/api/tests/client_integration.rs+++ b/rust/crates/api/tests/client_integration.rs@@ -545,6 +545,71 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {}}+#[tokio::test]+async fn retries_multiple_retryable_failures_with_exponential_backoff_and_jitter() {+ let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));+ let server = spawn_server(+ state.clone(),+ vec![+ http_response(+ "429 Too Many Requests",+ "application/json",+ "{\"type\":\"error\",\"error\":{\"type\":\"rate_limit_error\",\"message\":\"slow down\"}}",+ ),+ http_response(+ "500 Internal Server Error",+ "application/json",+ "{\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"boom\"}}",+ ),+ http_response(+ "503 Service Unavailable",+ "application/json",+ "{\"type\":\"error\",\"error\":{\"type\":\"overloaded_error\",\"message\":\"busy\"}}",+ ),+ http_response(+ "429 Too Many Requests",+ "application/json",+ "{\"type\":\"error\",\"error\":{\"type\":\"rate_limit_error\",\"message\":\"slow down again\"}}",+ ),+ http_response(+ "503 Service Unavailable",+ "application/json",+ "{\"type\":\"error\",\"error\":{\"type\":\"overloaded_error\",\"message\":\"still busy\"}}",+ ),+ http_response(+ "200 OK",+ "application/json",+ "{\"id\":\"msg_exp_retry\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Recovered after 5\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"output_tokens\":2}}",+ ),+ ],+ )+ .await;++ let client = ApiClient::new("test-key")+ .with_base_url(server.base_url())+ .with_retry_policy(8, Duration::from_millis(1), Duration::from_millis(4));+ let started_at = std::time::Instant::now();++ let response = client+ .send_message(&sample_request(false))+ .await+ .expect("8-retry policy should absorb 5 retryable failures");++ let elapsed = started_at.elapsed();+ assert_eq!(response.total_tokens(), 5);+ assert_eq!(+ state.lock().await.len(),+ 6,+ "client should issue 1 original + 5 retry requests before the 200"+ );+ // Jittered sleeps are bounded by 2 * max_backoff per retry (base + jitter),+ // so 5 sleeps fit comfortably below this upper bound with generous slack.+ assert!(+ elapsed < Duration::from_secs(5),+ "retries should complete promptly, took {elapsed:?}"+ );+}+#[tokio::test]#[allow(clippy::await_holding_lock)]async fn send_message_reuses_recent_completion_cache_entries() {