mirror of
https://github.com/openai/codex.git
synced 2026-11-20 22:40:37 +00:00
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
This commit is contained in:
@@ -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<DenialResample>,
|
||||
retry_prompt: Option<Arc<Prompt>>,
|
||||
output: Vec<ResponseItem>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct ResponseResampling {
|
||||
policy: Option<Arc<DenialResample>>,
|
||||
buffered_output: Option<Vec<ResponseItem>>,
|
||||
review: Option<BufferedReview>,
|
||||
pub(crate) accepted_output: VecDeque<ResponseItem>,
|
||||
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<Prompt>) -> Self {
|
||||
let policy = session
|
||||
.services
|
||||
.thread_extension_data
|
||||
.get::<DenialResample>();
|
||||
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<ResponseEvent> {
|
||||
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<Output = CodexResult<SamplingStream>> + Send,
|
||||
cancellation_token: &CancellationToken,
|
||||
) -> CodexResult<SamplingStream> {
|
||||
self.retry_pending = false;
|
||||
self.buffered_output = Some(Vec::new());
|
||||
request.or_cancel(cancellation_token).await?
|
||||
end_turn: Option<bool>,
|
||||
has_usage: bool,
|
||||
) -> Option<Arc<Prompt>> {
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<Prompt>| {
|
||||
let mut stream_request = async |prompt: Arc<Prompt>| {
|
||||
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;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user