Lightweight coding agent that runs in your terminal
Rust
Honor server retry advice across Responses retries and fallback (#49441)
Adam Perry @ OpenAI6ba4bf9e647c
diff --git a/codex-rs/codex-api/src/api_bridge_tests.rs b/codex-rs/codex-api/src/api_bridge_tests.rsindex 56c4838ef6..9c4cd1be08 100644--- a/codex-rs/codex-api/src/api_bridge_tests.rs+++ b/codex-rs/codex-api/src/api_bridge_tests.rs@@ -74,6 +74,56 @@ async fn map_api_error_preserves_retry_delay() {}}+/// Mapping a new error category preserves elapsed advice without making hard failures retryable.+#[tokio::test(start_paused = true)]+async fn http_retry_deadline_survives_mapping_and_respects_terminal_errors() {+ use std::time::Duration;++ let advice = RetryAfter::from_delay(Duration::from_secs(10)).expect("retry advice");+ tokio::time::advance(Duration::from_secs(4)).await;+ for (status, code, retryable) in [+ (503, "server_is_overloaded", true),+ (429, "rate_limit_exceeded", true),+ (429, "insufficient_quota", false),+ (429, "usage_limit_reached", false),+ (400, "cyber_policy", false),+ ] {+ let error = map_api_error(ApiError::Transport(TransportError::Http {+ status: http::StatusCode::from_u16(status).unwrap(),+ url: None,+ headers: None,+ body: Some(serde_json::json!({"error": {"type": code, "code": code, "message": "sensitive upstream detail"}}).to_string()),+ retry_after: Some(advice),+ }));+ assert_eq!(+ (error.retry_after(), error.server_retry_delay()),+ (Some(advice), Some(Duration::from_secs(6))),+ "{code}",+ );+ assert_eq!(+ error.retry_delay(/*retry_count*/ 1),+ retryable.then_some(Duration::from_secs(6)),+ "{code}",+ );+ if status == 429 && retryable {+ assert_eq!(+ (+ error.to_codex_protocol_error(),+ error.http_status_code_value(),+ error.to_string()+ ),+ (+ CodexErrorInfo::ResponseTooManyFailedAttempts {+ http_status_code: Some(429),+ },+ Some(429),+ "exceeded retry limit, last status: 429 Too Many Requests".to_string(),+ ),+ );+ }+ }+}+#[test]fn map_api_error_distinguishes_capacity_from_slow_down() {for (code, expected, retryable) in [diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket.rs b/codex-rs/codex-api/src/endpoint/responses_websocket.rsindex 7f3ebd7aac..b4463500b9 100644--- a/codex-rs/codex-api/src/endpoint/responses_websocket.rs+++ b/codex-rs/codex-api/src/endpoint/responses_websocket.rs@@ -14,6 +14,7 @@ use crate::sse::process_responses_event;use crate::telemetry::WebsocketTelemetry;use codex_client::TransportError;use codex_http_client::HttpClientFactory;+use codex_http_client::RetryAfter;use codex_websocket_client::WebSocketConnection;use codex_websocket_client::WebSocketConnector;use futures::FutureExt;@@ -570,6 +571,7 @@ fn map_ws_error(err: WsError, url: &Url) -> ApiError {WsError::Http(response) => {let status = response.status();let headers = response.headers().clone();+ let retry_after = RetryAfter::from_headers(&headers);let body = response.body().as_ref()@@ -579,7 +581,7 @@ fn map_ws_error(err: WsError, url: &Url) -> ApiError {url: Some(url.to_string()),headers: Some(headers),body,- retry_after: None,+ retry_after,})}WsError::ConnectionClosed | WsError::AlreadyClosed => {diff --git a/codex-rs/core/src/responses_retry.rs b/codex-rs/core/src/responses_retry.rsindex c8edc8b9d4..048a68bfc9 100644--- a/codex-rs/core/src/responses_retry.rs+++ b/codex-rs/core/src/responses_retry.rs@@ -1,5 +1,6 @@//! Shared retry and transport fallback decisions for Responses requests.//! Content-filter guidance is recorded for sampling requests before retry decisions.+//! Server advice controls timing without extending configured retry limits.use std::time::Duration;@@ -116,13 +117,16 @@ pub(crate) async fn handle_response_stream_error(return Ok(());}- // TODO(anp): Respect server retry advice before issuing the fallback HTTP request.if retry_state.retries >= max_retries&& client_session.try_switch_fallback_transport(&turn_context.session_telemetry,turn_context.model_info(),){+ // Changing transport must not bypass the server's retry deadline.+ if let Some(retry_after) = retry_after {+ tokio::time::sleep_until(retry_after.deadline()).await;+ }sess.send_event(turn_context,EventMsg::Warning(WarningEvent {diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rsindex 7455ff786f..2dced3650d 100644--- a/codex-rs/core/tests/suite/compact.rs+++ b/codex-rs/core/tests/suite/compact.rs@@ -23,6 +23,7 @@ use codex_protocol::openai_models::ModelInfo;use codex_protocol::openai_models::ModelServiceTier;use codex_protocol::openai_models::ModelsResponse;use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::CodexErrorInfo;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::HookEventName;use codex_protocol::protocol::HookRunStatus;@@ -3074,6 +3075,193 @@ async fn pre_sampling_compact_falls_back_after_previous_model_stream_retries_are);}+/// Both compaction models keep the configured retry budget when the server supplies advice,+/// including the selected model's final attempt.+#[test_case::test_case(2; "selected_model_recovers")]+#[test_case::test_case(3; "selected_model_exhausts_retries")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn pre_sampling_compact_advised_errors_fall_back_then_retry_on_selected_model(+ selected_model_failures: usize,+) {+ skip_if_no_network!();++ let server = MockServer::start().await;+ let previous_model = "gpt-5.4";+ let selected_model = "gpt-5.2";+ let _models_mock = mount_models_once(+ &server,+ ModelsResponse {+ models: vec![+ model_info_with_context_window(previous_model, /*context_window*/ 273_000),+ model_info_with_context_window(selected_model, /*context_window*/ 125_000),+ ],+ },+ )+ .await;+ let overload = wiremock::ResponseTemplate::new(/*s*/ 503)+ .insert_header("Retry-After", "0")+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } }));+ let mut responses = vec![+ sse_response(sse(vec![+ ev_assistant_message("m1", "before switch"),+ ev_completed_with_tokens("r1", /*total_tokens*/ 120_000),+ ])),+ overload.clone(), // Old model: initial attempt and two retries.+ overload.clone(),+ overload.clone(),+ ];+ responses.extend(vec![overload; selected_model_failures]);+ if selected_model_failures < 3 {+ responses.extend([+ sse_response(remote_v2_compaction_response()),+ sse_response(sse(vec![+ ev_assistant_message("m3", "after switch"),+ ev_completed_with_tokens("r3", /*total_tokens*/ 100),+ ])),+ ]);+ }+ let request_log = mount_response_sequence(&server, responses).await;+ let mut model_provider = openai_model_provider(&server);+ model_provider.request_max_retries = Some(0);+ model_provider.stream_max_retries = Some(2);+ let test = test_codex()+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_model(previous_model)+ .with_config(move |config| {+ config.model_provider = model_provider;+ set_test_compact_prompt(config);+ })+ .build_with_auto_env(&server)+ .await+ .expect("build codex");+ test.codex+ .start_or_steer_turn(disabled_permission_user_turn(+ "before switch",+ test.cwd.path().to_path_buf(),+ previous_model.to_string(),+ ))+ .await+ .expect("submit first turn");+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ test.codex+ .start_or_steer_turn(disabled_permission_user_turn(+ "after switch",+ test.cwd.path().to_path_buf(),+ selected_model.to_string(),+ ))+ .await+ .expect("submit selected-model turn");+ if selected_model_failures < 3 {+ assert_compaction_uses_turn_lifecycle_id(&test.codex).await;+ } else {+ let mut errors = Vec::new();+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::Error(error) => errors.push(error.codex_error_info),+ EventMsg::TurnComplete(event) => {+ assert_eq!(+ event.error.and_then(|error| error.codex_error_info),+ Some(CodexErrorInfo::ServerOverloaded)+ );+ break;+ }+ _ => {}+ }+ }+ assert_eq!(errors, vec![Some(CodexErrorInfo::ServerOverloaded)]);+ }+ let actual_models = request_log+ .requests()+ .iter()+ .map(|request| {+ request.body_json()["model"]+ .as_str()+ .expect("request model")+ .to_string()+ })+ .collect::<Vec<_>>();+ let mut expected_models = vec![+ previous_model, // First turn.+ previous_model, // Old-model compaction attempt and retries.+ previous_model,+ previous_model,+ selected_model, // Selected-model compaction attempt and retries.+ selected_model,+ selected_model,+ ];+ if selected_model_failures < 3 {+ expected_models.push(selected_model); // Sampling after compaction succeeds.+ }+ assert_eq!(actual_models, expected_models);+}++/// Manual compaction keeps the configured retry limit even when the server supplies advice.+#[test_case::test_case(0; "no_retries")]+#[test_case::test_case(2; "two_retries")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn manual_remote_compact_advice_respects_retry_limit(max_retries: u64) {+ skip_if_no_network!();++ let server = start_mock_server().await;+ let overload = wiremock::ResponseTemplate::new(/*s*/ 503)+ .insert_header("Retry-After", "0")+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } }));+ let request_log =+ mount_response_sequence(&server, vec![overload; (max_retries + 1) as usize]).await;+ let mut model_provider = openai_model_provider(&server);+ model_provider.request_max_retries = Some(0);+ model_provider.stream_max_retries = Some(max_retries);+ let test = test_codex()+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_model("gpt-5.4")+ .with_config(move |config| {+ config.model_provider = model_provider;+ set_test_compact_prompt(config);+ })+ .build_with_auto_env(&server)+ .await+ .expect("build codex");++ test.codex.submit(Op::Compact).await.expect("run /compact");+ let mut errors = Vec::new();+ let mut reconnect_messages = Vec::new();+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::Error(error) => errors.push(error.codex_error_info),+ EventMsg::StreamError(error) => reconnect_messages.push(error.message),+ EventMsg::TurnComplete(event) => {+ assert_eq!(+ event.error.and_then(|error| error.codex_error_info),+ Some(CodexErrorInfo::ServerOverloaded)+ );+ break;+ }+ _ => {}+ }+ }+ assert_eq!(errors, vec![Some(CodexErrorInfo::ServerOverloaded)]);+ assert_eq!(+ reconnect_messages,+ (1..=max_retries)+ .map(|retry| format!("Reconnecting... {retry}/{max_retries}"))+ .collect::<Vec<_>>()+ );+ let models = request_log+ .requests()+ .iter()+ .map(|request| {+ request.body_json()["model"]+ .as_str()+ .expect("request model")+ .to_string()+ })+ .collect::<Vec<_>>();+ assert_eq!(models, vec!["gpt-5.4"; (max_retries + 1) as usize]);+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn pre_sampling_compact_keeps_unknown_previous_model_for_api_key_auth_and_custom_provider() {skip_if_no_network!();diff --git a/codex-rs/core/tests/suite/retry_after.rs b/codex-rs/core/tests/suite/retry_after.rsindex 4bb5da9a8d..f69caf5208 100644--- a/codex-rs/core/tests/suite/retry_after.rs+++ b/codex-rs/core/tests/suite/retry_after.rs@@ -51,11 +51,11 @@ const SECOND_RETRY_MIN_DELAY: Duration = Duration::from_millis(360);const SECOND_RETRY_MAX_DELAY: Duration = Duration::from_millis(440);#[derive(Debug, PartialEq, Eq)]-struct RetryTelemetryEvent {+pub(super) struct RetryTelemetryEvent {attempt: u64,- delay: Duration,- layer: String,- operation: String,+ pub(super) delay: Duration,+ pub(super) layer: String,+ pub(super) operation: String,}#[derive(Default)]@@ -193,7 +193,7 @@ where}}-struct RetryTelemetryCapture {+pub(super) struct RetryTelemetryCapture {events: mpsc::UnboundedReceiver<RetryTelemetryEvent>,resumptions: mpsc::UnboundedReceiver<Duration>,_subscriber: DefaultGuard,@@ -201,7 +201,7 @@ struct RetryTelemetryCapture {}impl RetryTelemetryCapture {- fn install() -> Self {+ pub(super) fn install() -> Self {let (sender, events) = mpsc::unbounded_channel();let (resumptions_sender, resumptions) = mpsc::unbounded_channel();// Avoid caching no interest when another test first reaches a shared callsite.@@ -225,7 +225,7 @@ impl RetryTelemetryCapture {}}- async fn next_retry(&mut self) -> RetryTelemetryEvent {+ pub(super) async fn next_retry(&mut self) -> RetryTelemetryEvent {tokio::time::timeout(Duration::from_secs(10), self.events.recv()).await.expect("timed out waiting for retry telemetry")@@ -275,7 +275,7 @@ async fn wait_for_turn_completion(test: &TestCodex) {assert_eq!(completed.error, None, "turn should complete successfully");}-/// HTTP overloads use the upstream header before another HTTP request.+/// HTTP overloads use server advice within the request and stream retry budgets.#[tokio::test(flavor = "current_thread")]async fn responses_http_uses_retry_after() -> Result<()> {skip_if_no_network!(Ok(()));@@ -285,6 +285,9 @@ async fn responses_http_uses_retry_after() -> Result<()> {let response_mock = responses::mount_response_sequence(&server,vec![+ ResponseTemplate::new(503)+ .insert_header("Retry-After", "1")+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } })),ResponseTemplate::new(503).insert_header("Retry-After", "1").set_body_json(json!({ "error": { "code": "server_is_overloaded" } })),@@ -298,7 +301,7 @@ async fn responses_http_uses_retry_after() -> Result<()> {let test = test_codex().with_config(|config| {config.model_provider.request_max_retries = Some(1);- config.model_provider.stream_max_retries = Some(0);+ config.model_provider.stream_max_retries = Some(1);}).build_with_auto_env(&server).await?;@@ -316,8 +319,79 @@ async fn responses_http_uses_retry_after() -> Result<()> {});assert!(wait_for_retry(&mut telemetry, &retry).await >= Duration::from_secs(1));+ let retry = telemetry.next_retry().await;+ assert!(retry.delay <= Duration::from_secs(1));+ assert_eq!(+ retry,+ RetryTelemetryEvent {+ attempt: 1,+ delay: retry.delay,+ layer: "stream".into(),+ operation: "sampling".into(),+ }+ );+ assert!(wait_for_retry(&mut telemetry, &retry).await >= Duration::from_secs(1));wait_for_turn_completion(&test).await;+ assert_eq!(response_mock.requests().len(), 3);+ assert_eq!(+ telemetry.events.try_recv(),+ Err(mpsc::error::TryRecvError::Empty)+ );+ Ok(())+}++/// A 429 with server advice retries in the sampling loop and completes without a terminal error.+#[tokio::test(flavor = "current_thread")]+async fn responses_http_429_uses_retry_after() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let mut telemetry = RetryTelemetryCapture::install();+ let server = responses::start_mock_server().await;+ let response_mock = responses::mount_response_sequence(+ &server,+ vec![+ ResponseTemplate::new(429)+ .insert_header("Retry-After", "1")+ .set_body_json(json!({ "error": { "code": "rate_limit_exceeded" } })),+ responses::sse_response(responses::sse(vec![+ responses::ev_response_created("recovered"),+ responses::ev_completed("recovered"),+ ])),+ ],+ )+ .await;+ let test = test_codex()+ .with_config(|config| {+ config.model_provider.request_max_retries = Some(0);+ config.model_provider.stream_max_retries = Some(1);+ })+ .build_with_auto_env(&server)+ .await?;++ submit_user_input(&test, "retry the rate-limited request").await?;+ let retry = telemetry.next_retry().await;+ assert!(retry.delay <= Duration::from_secs(1));+ assert_eq!(+ retry,+ RetryTelemetryEvent {+ attempt: 1,+ delay: retry.delay,+ layer: "stream".into(),+ operation: "sampling".into(),+ }+ );+ assert!(wait_for_retry(&mut telemetry, &retry).await >= Duration::from_secs(1));+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::Error(error) => panic!("unexpected terminal error: {error:?}"),+ EventMsg::TurnComplete(completed) => {+ assert_eq!(completed.error, None);+ break;+ }+ _ => {}+ }+ }assert_eq!(response_mock.requests().len(), 2);assert_eq!(telemetry.events.try_recv(),@@ -425,31 +499,40 @@ async fn exhausted_http_retries_preserve_deadline_through_error_mapping() {assert_eq!(outer_error.server_retry_delay(), Some(Duration::ZERO));}-/// Headerless HTTP overloads currently exhaust request retries before emitting one terminal error.+/// Retry advice changes delays but never extends either retry budget or its displayed count.+#[test_case::test_case(None, 2, 3; "without_advice")]+#[test_case::test_case(Some("0"), 0, 3; "advice_without_stream_retries")]+#[test_case::test_case(Some("0"), 2, 9; "advice_with_stream_retries")]#[tokio::test(flavor = "current_thread")]-async fn responses_http_overload_without_retry_after_exhausts_request_retries() -> Result<()> {+async fn responses_http_overload_respects_retry_limits(+ retry_after: Option<&str>,+ stream_max_retries: u64,+ expected_requests: usize,+) -> Result<()> {skip_if_no_network!(Ok(()));let server = responses::start_mock_server().await;+ let mut overload = ResponseTemplate::new(503)+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } }));+ if let Some(retry_after) = retry_after {+ overload = overload.insert_header("Retry-After", retry_after);+ }Mock::given(method("POST")).and(path("/v1/responses"))- .respond_with(- ResponseTemplate::new(503)- .set_body_json(json!({ "error": { "code": "server_is_overloaded" } })),- )+ .respond_with(overload).mount(&server).await;let test = test_codex()- .with_config(|config| {+ .with_config(move |config| {config.model_provider.request_max_retries = Some(2);- config.model_provider.stream_max_retries = Some(2);+ config.model_provider.stream_max_retries = Some(stream_max_retries);}).build_with_auto_env(&server).await?;submit_user_input(&test, "reject the disabled model").await?;let mut error_events = 0;- let mut stream_error_events = 0;+ let mut reconnect_messages = Vec::new();tokio::time::timeout(Duration::from_secs(10), async {loop {match wait_for_event(&test.codex, |_| true).await {@@ -464,7 +547,7 @@ async fn responses_http_overload_without_retry_after_exhausts_request_retries()"Selected model is at capacity. Please try a different model.");}- EventMsg::StreamError(_) => stream_error_events += 1,+ EventMsg::StreamError(error) => reconnect_messages.push(error.message),EventMsg::TurnComplete(event) => {assert_eq!(event.error.and_then(|error| error.codex_error_info),@@ -480,7 +563,14 @@ async fn responses_http_overload_without_retry_after_exhausts_request_retries().expect("overload retries should finish the turn within 10 seconds");assert_eq!(error_events, 1);- assert_eq!(stream_error_events, 0);+ let expected_messages = if retry_after.is_some() {+ (1..=stream_max_retries)+ .map(|retry| format!("Reconnecting... {retry}/{stream_max_retries}"))+ .collect::<Vec<_>>()+ } else {+ Vec::new()+ };+ assert_eq!(reconnect_messages, expected_messages);let request_count = server.received_requests().await@@ -489,8 +579,8 @@ async fn responses_http_overload_without_retry_after_exhausts_request_retries().filter(|request| request.url.path() == "/v1/responses").count();assert_eq!(- request_count, 3,- "headerless overload should exhaust the configured request retries"+ request_count, expected_requests,+ "overload should exhaust the configured retry budgets");Ok(())@@ -1709,6 +1799,79 @@ async fn websocket_connection_limit_retries_with_local_backoff() -> Result<()> {Ok(())}+/// Advised WebSocket failures reach HTTP after the existing retry budget. HTTP+/// recovery uses its own retry budget and honors the preceding advice deadlines.+#[tokio::test(flavor = "current_thread")]+async fn websocket_upgrade_rejection_uses_retry_after() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = responses::start_mock_server().await;+ let prewarm_rejection = Mock::given(method("GET"))+ .and(path("/v1/responses"))+ .respond_with(ResponseTemplate::new(/*s*/ 503))+ .up_to_n_times(/*n*/ 1)+ .expect(/*r*/ 1)+ .mount_as_scoped(&server)+ .await;+ Mock::given(method("GET"))+ .and(path("/v1/responses"))+ .respond_with(+ ResponseTemplate::new(/*s*/ 503)+ .insert_header("Retry-After", "1")+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } })),+ )+ .mount(&server)+ .await;+ let http_overload = ResponseTemplate::new(/*s*/ 503)+ .insert_header("Retry-After", "0")+ .set_body_json(json!({ "error": { "code": "server_is_overloaded" } }));+ let response_mock = responses::mount_response_sequence(+ &server,+ vec![+ http_overload,+ ResponseTemplate::new(/*s*/ 200)+ .insert_header("content-type", "text/event-stream")+ .set_body_string(responses::sse(vec![+ responses::ev_response_created("recovered"),+ responses::ev_completed("recovered"),+ ])),+ ],+ )+ .await;+ let test = test_codex()+ .with_config(|config| {+ config.model_catalog = Some(bundled_models_response().expect("bundled models"));+ config.model_provider.supports_websockets = true;+ config.model_provider.request_max_retries = Some(0);+ config.model_provider.stream_max_retries = Some(1);+ })+ .build_with_auto_env(&server)+ .await?;++ // Prewarm is best effort; start the advised failures in the sampling retry loop.+ tokio::time::timeout(+ Duration::from_secs(10),+ prewarm_rejection.wait_until_satisfied(),+ )+ .await?;+ drop(prewarm_rejection);+ let start = Instant::now();+ submit_user_input(&test, "retry the rejected websocket upgrade").await?;+ wait_for_turn_completion(&test).await;++ // Both WebSocket advice deadlines apply, including the one before transport fallback.+ assert!(start.elapsed() >= Duration::from_secs(2));+ let requests = server.received_requests().await.unwrap_or_default();+ let methods = requests+ .iter()+ .filter(|request| request.url.path() == "/v1/responses")+ .map(|request| request.method.as_str())+ .collect::<Vec<_>>();+ assert_eq!(methods, vec!["GET", "GET", "GET", "POST", "POST"]);+ assert_eq!(response_mock.requests().len(), 2);+ Ok(())+}+// TODO(anp) respect Retry-After/// Nested websocket retry headers are currently ignored, leaving rate-limit errors terminal.#[tokio::test(flavor = "current_thread")]diff --git a/codex-rs/protocol/src/error.rs b/codex-rs/protocol/src/error.rsindex d0dad844bd..19134d6f3e 100644--- a/codex-rs/protocol/src/error.rs+++ b/codex-rs/protocol/src/error.rs@@ -403,18 +403,19 @@ impl CodexErr {| CodexErrorDetails::UnsupportedOperation(_)| CodexErrorDetails::Sandbox(_)| CodexErrorDetails::LandlockSandboxExecutableNotProvided- | CodexErrorDetails::RetryLimit(_)| CodexErrorDetails::ContextWindowExceeded| CodexErrorDetails::ThreadNotFound(_)| CodexErrorDetails::AgentLimitReached { .. }| CodexErrorDetails::Spawn| CodexErrorDetails::SessionConfiguredNotFirstEvent| CodexErrorDetails::UsageLimitReached(_)- | CodexErrorDetails::ServerOverloaded| CodexErrorDetails::FlexUnavailable| CodexErrorDetails::CyberPolicy { .. }| CodexErrorDetails::BioPolicy { .. }| CodexErrorDetails::MisalignmentPolicyViolation { .. } => None,+ CodexErrorDetails::ServerOverloaded | CodexErrorDetails::RetryLimit(_) => {+ self.server_retry_delay()+ }CodexErrorDetails::Stream(..)| CodexErrorDetails::ContentFilter| CodexErrorDetails::RateLimitExceeded(_)