From 63598243af3fa93ac670fb39da48b4b0967fb365 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Fri, 20 Nov 2026 22:00:30 +0000 Subject: [PATCH] Limit guardian response resampling to one retry (#62852) ## Why When the retried response also meets the guardian's resampling criteria, it can trigger another model request and keep the turn from finishing. ## What changed Consume the original prompt when scheduling the retry. The second verdict stays buffered until completion and is replayed after usage accounting, even if it also meets the resampling criteria. Usage from the discarded first response still counts toward spending. GitOrigin-RevId: f8ded8f31bd7d9e440c0c92a92a80480acec61d2 --- .../core/src/guardian/response_resampling.rs | 82 +++++++++---------- codex-rs/core/src/session/turn.rs | 23 +++--- 2 files changed, 51 insertions(+), 54 deletions(-) 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; }