diff --git a/codex-rs/core/src/guardian/response_resampling.rs b/codex-rs/core/src/guardian/response_resampling.rs index 3750c82674..5be6d76aa0 100644 --- a/codex-rs/core/src/guardian/response_resampling.rs +++ b/codex-rs/core/src/guardian/response_resampling.rs @@ -2,17 +2,14 @@ //! Completions reach the shared accounting path before output replay or retry. use std::collections::VecDeque; -use std::future::Future; use std::sync::Arc; -use codex_async_utils::OrCancelExt; use codex_guardian_reviewer::DenialResample; use codex_guardian_reviewer::GuardianReviewResponse; -use codex_protocol::error::Result as CodexResult; use codex_protocol::models::ResponseItem; use futures::StreamExt; -use tokio_util::sync::CancellationToken; +use crate::client_common::Prompt; use crate::client_common::ResponseEvent; use crate::client_common::SamplingEvent; use crate::client_common::SamplingStream; @@ -20,24 +17,31 @@ use crate::session::session::Session; use crate::session::turn::get_last_assistant_message_from_turn; use crate::tools::ToolRouter; +struct BufferedReview { + policy: Arc, + retry_prompt: Option>, + output: Vec, +} + #[derive(Default)] pub(crate) struct ResponseResampling { - policy: Option>, - buffered_output: Option>, + review: Option, pub(crate) accepted_output: VecDeque, - pub(crate) retry_pending: bool, pub(crate) update_usage_boundary: bool, } impl ResponseResampling { - pub(crate) fn new(session: &Session) -> Self { + pub(crate) fn new(session: &Session, prompt: &Arc) -> Self { let policy = session .services .thread_extension_data .get::(); Self { - buffered_output: policy.as_ref().map(|_| Vec::new()), - policy, + review: policy.map(|policy| BufferedReview { + policy, + retry_prompt: Some(Arc::clone(prompt)), + output: Vec::new(), + }), ..Self::default() } } @@ -54,17 +58,18 @@ impl ResponseResampling { event: ResponseEvent, router: &ToolRouter, ) -> Option { - let (Some(policy), Some(output)) = (&self.policy, self.buffered_output.as_mut()) else { + let Some(review) = self.review.as_mut() else { return Some(event); }; match event { ResponseEvent::OutputItemDone(item) => { let dispatch = !matches!(router.build_tool_call(item.clone()), Ok(None)); - output.push(item); + review.output.push(item); if dispatch { // Tool calls proceed immediately, with their preceding reasoning. - self.accepted_output.extend(std::mem::take(output)); - self.buffered_output = None; + self.accepted_output + .extend(std::mem::take(&mut review.output)); + self.review = None; } return None; } @@ -75,27 +80,8 @@ impl ResponseResampling { | ResponseEvent::ReasoningSummaryDone { .. } | ResponseEvent::ReasoningContentDelta { .. } | ResponseEvent::ReasoningSummaryPartAdded { .. } => return None, - ResponseEvent::Completed { - end_turn, - ref token_usage, - .. - } => { - let output = std::mem::take(output); - self.buffered_output = None; - if end_turn != Some(false) - && policy.should_resample(GuardianReviewResponse::new( - get_last_assistant_message_from_turn(output.iter()).unwrap_or_default(), - )) - { - self.retry_pending = true; - } else { - self.accepted_output.extend(output); - } - // Account for this completion before replaying any buffered output. - self.update_usage_boundary = - token_usage.is_some() && !self.accepted_output.is_empty(); - } ResponseEvent::Created { .. } + | ResponseEvent::Completed { .. } | ResponseEvent::SafetyBuffering(_) | ResponseEvent::ServerModel(_) | ResponseEvent::ModelVerifications(_) @@ -108,14 +94,26 @@ impl ResponseResampling { Some(event) } - /// Called after the denied completion has been accounted for, with the unchanged request. - pub(crate) async fn retry( + /// Accepts buffered output or returns the original prompt to retry after accounting. + pub(crate) fn finish_response( &mut self, - request: impl Future> + Send, - cancellation_token: &CancellationToken, - ) -> CodexResult { - self.retry_pending = false; - self.buffered_output = Some(Vec::new()); - request.or_cancel(cancellation_token).await? + end_turn: Option, + has_usage: bool, + ) -> Option> { + let review = self.review.as_mut()?; + let output = std::mem::take(&mut review.output); + if let Some(prompt) = review.retry_prompt.take() + && end_turn != Some(false) + && review.policy.should_resample(GuardianReviewResponse::new( + get_last_assistant_message_from_turn(output.iter()).unwrap_or_default(), + )) + { + // Keep buffering until the second verdict can be replayed after accounting. + return Some(prompt); + } + self.review = None; + self.update_usage_boundary = has_usage && !output.is_empty(); + self.accepted_output.extend(output); + None } } diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index 92cd062443..b56e065296 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -3154,13 +3154,13 @@ async fn try_run_sampling_request( let mut response_completed = false; let mut includes_reasoning = step_context.settings.model_info.use_responses_lite; let accept_actor_assessments = turn_context.config.guardian_model_provider.is_none(); - let mut resampling = crate::guardian::ResponseResampling::new(&sess); let prompt = Arc::new(prompt); + let mut resampling = crate::guardian::ResponseResampling::new(&sess, &prompt); let interrupt_at_boundary = SamplingInterrupt::enabled(&turn_context); - let mut stream_request = async |prompt: &Arc| { + let mut stream_request = async |prompt: Arc| { let send = client_session .open_model_response( - prompt, + &prompt, &step_context.settings.model_info, &step_context.session_telemetry, SamplingOptions { @@ -3188,7 +3188,7 @@ async fn try_run_sampling_request( ) .await }; - let mut stream = match stream_request(&prompt) + let mut stream = match stream_request(prompt) .or_cancel(&cancellation_token) .await? { @@ -3745,6 +3745,7 @@ async fn try_run_sampling_request( reasoning_removals: _, end_turn, } => { + let retry_prompt = resampling.finish_response(end_turn, token_usage.is_some()); if let Some(accepted) = pending_audio.take() { sess.record_retained_context( codex_history::RetainedContextEvent::AcceptedFileAudio { @@ -3788,7 +3789,7 @@ async fn try_run_sampling_request( provider: token_usage, charge: hook_output, }, - if resampling.retry_pending { + if retry_prompt.is_some() { super::TokenUsageContext::SpendingOnly } else { super::TokenUsageContext::Sampling { @@ -3809,17 +3810,15 @@ async fn try_run_sampling_request( last_agent_message, }); } - if resampling.retry_pending { + if let Some(prompt) = retry_prompt { response_completed = false; response_id_for_assessment = None; pending_assessment = None; includes_reasoning = step_context.settings.model_info.use_responses_lite; - stream = match resampling - .retry(stream_request(&prompt), &cancellation_token) - .await - { - Ok(stream) => stream, - Err(error) => break Err(error), + stream = match stream_request(prompt).or_cancel(&cancellation_token).await { + Ok(Ok(stream)) => stream, + Ok(Err(error)) => break Err(error), + Err(error) => break Err(error.into()), }; continue; }