diff --git a/codex-rs/app-server/tests/suite/v2/safety_buffering.rs b/codex-rs/app-server/tests/suite/v2/safety_buffering.rs index 81d0fbd821..c83787f98c 100644 --- a/codex-rs/app-server/tests/suite/v2/safety_buffering.rs +++ b/codex-rs/app-server/tests/suite/v2/safety_buffering.rs @@ -29,7 +29,7 @@ async fn direct_websocket_safety_buffering_reaches_app_server_notification() -> buffering_event["safety_buffering"] = json!({ "use_cases": ["cyber"], "reasons": ["user_risk"], - "faster_model": FASTER_MODEL, + "retry_model": FASTER_MODEL, }); let websocket_server = responses::start_websocket_server(vec![vec![ vec![ diff --git a/codex-rs/codex-api/src/common.rs b/codex-rs/codex-api/src/common.rs index 7f4b3974a6..a8e4bf7a6d 100644 --- a/codex-rs/codex-api/src/common.rs +++ b/codex-rs/codex-api/src/common.rs @@ -10,6 +10,7 @@ use codex_protocol::protocol::TurnModerationMetadataEvent; use codex_protocol::protocol::W3cTraceContext; use futures::Stream; use serde::Deserialize; +use serde::Deserializer; use serde::Serialize; use serde_json::Value; use std::collections::HashMap; @@ -121,6 +122,9 @@ pub struct SafetyBuffering { pub reasons: Vec, #[serde(skip)] pub show_buffering_ui: bool, + #[serde(rename = "retry_model", default)] + pub(crate) wire_retry_model: WireRetryModel, + #[serde(skip)] pub faster_model: Option, } @@ -131,11 +135,30 @@ impl SafetyBuffering { self.faster_model.clone_from(&treatment.faster_model); } else { self.show_buffering_ui = true; + if let WireRetryModel::Value(retry_model) = &self.wire_retry_model { + self.faster_model.clone_from(retry_model); + } } self } } +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub(crate) enum WireRetryModel { + #[default] + Missing, + Value(Option), +} + +impl<'de> Deserialize<'de> for WireRetryModel { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + Option::::deserialize(deserializer).map(Self::Value) + } +} + #[derive(Debug, Clone, Default, PartialEq, Eq)] pub(crate) struct SafetyBufferingTreatment { pub show_buffering_ui: bool, diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket.rs b/codex-rs/codex-api/src/endpoint/responses_websocket.rs index 059eb5b2c6..212b6ac7bb 100644 --- a/codex-rs/codex-api/src/endpoint/responses_websocket.rs +++ b/codex-rs/codex-api/src/endpoint/responses_websocket.rs @@ -3,6 +3,7 @@ use crate::common::ResponseEvent; use crate::common::ResponseStream; use crate::common::ResponsesWsRequest; use crate::common::SafetyBufferingTreatment; +use crate::common::WireRetryModel; use crate::error::ApiError; use crate::provider::Provider; use crate::rate_limits::parse_rate_limit_event; @@ -636,6 +637,7 @@ async fn run_websocket_response_stream( ) -> Result<(), ApiError> { let mut last_server_model: Option = None; let mut safety_buffering_treatment: Option = None; + let mut wire_retry_model: Option = None; send_websocket_request( ws_stream, request_text, @@ -691,8 +693,11 @@ async fn run_websocket_response_stream( } let model_verifications = event.model_verifications(); let turn_moderation_metadata = event.turn_moderation_metadata(); - let safety_buffering = - safety_buffering_for_event(&event, &mut safety_buffering_treatment); + let safety_buffering = safety_buffering_for_event( + &event, + &mut safety_buffering_treatment, + &mut wire_retry_model, + ); if event.kind() == "codex.rate_limits" { if let Some(snapshot) = parse_rate_limit_event(&text) { let _ = tx_event.send(Ok(ResponseEvent::RateLimits(snapshot))).await; @@ -770,6 +775,7 @@ async fn run_websocket_response_stream( fn safety_buffering_for_event( event: &ResponsesStreamEvent, treatment: &mut Option, + wire_retry_model: &mut Option, ) -> Option { if let Some(headers) = event.headers.as_ref().and_then(Value::as_object) && let Some(updated_treatment) = @@ -777,9 +783,19 @@ fn safety_buffering_for_event( { *treatment = Some(updated_treatment); } - event - .safety_buffering() - .map(|buffering| buffering.with_treatment(treatment.as_ref())) + event.safety_buffering().map(|mut buffering| { + if treatment.is_none() { + match &buffering.wire_retry_model { + WireRetryModel::Value(retry_model) => { + wire_retry_model.clone_from(retry_model); + } + WireRetryModel::Missing => { + buffering.wire_retry_model = WireRetryModel::Value(wire_retry_model.clone()); + } + } + } + buffering.with_treatment(treatment.as_ref()) + }) } async fn send_websocket_request( @@ -1049,19 +1065,20 @@ mod tests { } #[test] - fn direct_websocket_safety_buffering_uses_wire_faster_model() { + fn direct_websocket_safety_buffering_uses_wire_retry_model() { let event: ResponsesStreamEvent = serde_json::from_value(json!({ "type": "response.output_text.delta", "safety_buffering": { "use_cases": ["cyber"], "reasons": ["user_risk"], - "faster_model": "gpt-fast-wire" + "retry_model": "gpt-fast-wire" } })) .expect("deserialize safety buffering event"); let mut treatment = None; + let mut wire_retry_model = None; - let buffering = safety_buffering_for_event(&event, &mut treatment) + let buffering = safety_buffering_for_event(&event, &mut treatment, &mut wire_retry_model) .expect("expected safety buffering payload"); assert!(buffering.show_buffering_ui); @@ -1083,14 +1100,17 @@ mod tests { "safety_buffering": { "use_cases": ["cyber"], "reasons": ["user_risk"], - "faster_model": "gpt-fast-wire" + "retry_model": "gpt-fast-wire" } })) .expect("deserialize safety buffering event"); let mut treatment = None; + let mut wire_retry_model = None; - assert!(safety_buffering_for_event(&metadata, &mut treatment).is_none()); - let buffering = safety_buffering_for_event(&event, &mut treatment) + assert!( + safety_buffering_for_event(&metadata, &mut treatment, &mut wire_retry_model).is_none() + ); + let buffering = safety_buffering_for_event(&event, &mut treatment, &mut wire_retry_model) .expect("expected safety buffering payload"); assert!(buffering.show_buffering_ui); @@ -1119,15 +1139,20 @@ mod tests { "safety_buffering": { "use_cases": ["cyber"], "reasons": ["user_risk"], - "faster_model": "gpt-fast-wire" + "retry_model": "gpt-fast-wire" } })) .expect("deserialize safety buffering event"); let mut treatment = None; + let mut wire_retry_model = None; - assert!(safety_buffering_for_event(&metadata, &mut treatment).is_none()); - let buffering = safety_buffering_for_event(&event, &mut treatment) - .expect("expected safety buffering payload"); + assert!( + safety_buffering_for_event(&metadata, &mut treatment, &mut wire_retry_model) + .is_none() + ); + let buffering = + safety_buffering_for_event(&event, &mut treatment, &mut wire_retry_model) + .expect("expected safety buffering payload"); assert_eq!(buffering.show_buffering_ui, expected_show_buffering_ui); assert_eq!(buffering.faster_model, None); @@ -1135,8 +1160,8 @@ mod tests { } #[test] - fn direct_websocket_safety_buffering_accepts_missing_and_null_faster_model() { - for faster_model in [None, Some(Value::Null)] { + fn direct_websocket_safety_buffering_accepts_missing_and_null_retry_model() { + for retry_model in [None, Some(Value::Null)] { let mut payload = json!({ "type": "response.output_text.delta", "safety_buffering": { @@ -1144,18 +1169,91 @@ mod tests { "reasons": ["user_risk"] } }); - if let Some(faster_model) = faster_model { - payload["safety_buffering"]["faster_model"] = faster_model; + if let Some(retry_model) = retry_model { + payload["safety_buffering"]["retry_model"] = retry_model; } let event: ResponsesStreamEvent = serde_json::from_value(payload).expect("deserialize safety buffering event"); let mut treatment = None; + let mut wire_retry_model = None; - let buffering = safety_buffering_for_event(&event, &mut treatment) - .expect("expected safety buffering payload"); + let buffering = + safety_buffering_for_event(&event, &mut treatment, &mut wire_retry_model) + .expect("expected safety buffering payload"); assert!(buffering.show_buffering_ui); assert_eq!(buffering.faster_model, None); } } + + #[test] + fn direct_websocket_safety_buffering_preserves_wire_retry_model() { + let event_with_retry: ResponsesStreamEvent = serde_json::from_value(json!({ + "type": "response.output_text.delta", + "safety_buffering": { + "use_cases": ["cyber"], + "reasons": ["user_risk"], + "retry_model": "gpt-fast-wire" + } + })) + .expect("deserialize safety buffering event"); + let event_without_retry: ResponsesStreamEvent = serde_json::from_value(json!({ + "type": "response.output_text.delta", + "safety_buffering": { + "use_cases": ["cyber"], + "reasons": ["user_risk"] + } + })) + .expect("deserialize safety buffering event"); + let mut treatment = None; + let mut wire_retry_model = None; + + let first = + safety_buffering_for_event(&event_with_retry, &mut treatment, &mut wire_retry_model) + .expect("expected first safety buffering payload"); + let second = + safety_buffering_for_event(&event_without_retry, &mut treatment, &mut wire_retry_model) + .expect("expected second safety buffering payload"); + + assert_eq!(first.faster_model.as_deref(), Some("gpt-fast-wire")); + assert_eq!(second.faster_model.as_deref(), Some("gpt-fast-wire")); + } + + #[test] + fn direct_websocket_safety_buffering_null_clears_wire_retry_model() { + let event_with_retry: ResponsesStreamEvent = serde_json::from_value(json!({ + "type": "response.output_text.delta", + "safety_buffering": { + "use_cases": ["cyber"], + "reasons": ["user_risk"], + "retry_model": "gpt-fast-wire" + } + })) + .expect("deserialize safety buffering event"); + let event_with_null_retry: ResponsesStreamEvent = serde_json::from_value(json!({ + "type": "response.output_text.delta", + "safety_buffering": { + "use_cases": ["cyber"], + "reasons": ["user_risk"], + "retry_model": null + } + })) + .expect("deserialize safety buffering event"); + let mut treatment = None; + let mut wire_retry_model = None; + + let first = + safety_buffering_for_event(&event_with_retry, &mut treatment, &mut wire_retry_model) + .expect("expected first safety buffering payload"); + let second = safety_buffering_for_event( + &event_with_null_retry, + &mut treatment, + &mut wire_retry_model, + ) + .expect("expected second safety buffering payload"); + + assert_eq!(first.faster_model.as_deref(), Some("gpt-fast-wire")); + assert_eq!(second.faster_model, None); + assert_eq!(wire_retry_model, None); + } } diff --git a/codex-rs/codex-api/src/sse/responses.rs b/codex-rs/codex-api/src/sse/responses.rs index b0fc4cc5a1..6485627e4f 100644 --- a/codex-rs/codex-api/src/sse/responses.rs +++ b/codex-rs/codex-api/src/sse/responses.rs @@ -1355,7 +1355,7 @@ mod tests { "safety_buffering": { "use_cases": ["cyber"], "reasons": ["user_risk"], - "faster_model": "unexpected-wire-model" + "retry_model": "unexpected-wire-model" } }), json!({