Enforce complete request budgets for Guardian reviews (#44281)

## Why

Review evidence can fit its own limits while exceeding the reviewer context window once history, tools, output format, and reminders are included. Tool continuations can also push an existing review over budget.

## What changed

- Select evidence after tools and turn context are resolved, reserving request overhead and a 256-token margin. Omit optional evidence while preserving required sections, and reject required evidence that cannot fit.
- Keep incoming evidence pending until budget selection succeeds so cancellation and compaction cannot record unselected input in reusable history.
- Check the assembled prompt before sampling, including retries and tool continuations. Retry budget failures with summary compaction once per model step, and retire reviewers whose budgets remain exhausted. Avoid history-resetting token-budget compaction for this recovery.
- Record section costs after budget selection.

## Testing

Add unit and integration coverage for required-evidence rejection, optional-evidence omission, reminder overhead, cancellation safety, incoming-review and tool-continuation compaction, and reviewer retirement after ineffective compaction.

GitOrigin-RevId: 2f7ef191b3f46032d295ad363eb7debf9d7a9684
This commit is contained in:
felixxia-oai authored and copyberry committed 2026-09-09 19:21:08 +00:00
1 parent 9caddc5cf5
commit fcd90d8f07
12 files changed
+879 -70

No files matched your search

+188
View File
@@ -0,0 +1,188 @@
//! Finalizes a pending reviewer input after tools and turn context are resolved.
//! The thread attachment is a single in-flight request, consumed before history
//! recording. Budget failures preserve it for a compaction retry; successful
//! finalization consumes it. It is not another retained history.
use codex_features::Feature;
use codex_guardian_context::ComposedContext;
use codex_guardian_context::RequestBudget;
use codex_guardian_context::effective_input_token_limit;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::error::CodexErr;
use codex_protocol::error::Result as CodexResult;
use codex_protocol::models::ResponseItem;
use crate::context::ContextualUserFragment;
use crate::context::GuardianBudgetOmission;
use crate::context_manager::estimate_item_token_count;
use crate::responses_metadata::CodexResponsesRequestKind;
use crate::session::TurnInput;
use crate::session::session::Session;
use crate::session::step_context::StepContext;
use crate::session::turn::build_prompt;
use crate::session::turn_context::TurnContext;
#[derive(Clone)]
pub(crate) struct PendingReviewContext(pub ComposedContext);
/// Reject inputs that cannot fit even without history or tools before Core tries
/// pre-turn compaction. This is only a feasibility check; its selected copy is
/// discarded. Actual selection waits for the complete first-step overhead.
pub(crate) async fn check_pending(session: &Session, turn: &TurnContext) -> CodexResult<()> {
let Some(pending) = session
.services
.thread_extension_data
.get::<PendingReviewContext>()
else {
return Ok(());
};
let base = session.get_prompt_base_instructions().await;
let minimum_prefix =
codex_protocol::protocol::TruncationPolicy::Bytes(base.text.len()).token_budget();
let maximum = effective_input_token_limit(turn.model_info(), turn.config.model_context_window)
.saturating_sub(super::request_budget::INPUT_TOKEN_MARGIN);
if pending.0.estimated_tokens().saturating_add(minimum_prefix) > maximum {
pending
.0
.clone()
.enforce_budget(
RequestBudget {
max_input_tokens: maximum,
existing_context_tokens: minimum_prefix,
},
GuardianBudgetOmission.render(),
)
.map_err(|error| CodexErr::InvalidRequest(error.to_string()))?;
}
Ok(())
}
pub(crate) async fn finalize(
session: &Session,
step: &StepContext,
input: &mut [TurnInput],
) -> CodexResult<()> {
let Some(pending) = session
.services
.thread_extension_data
.get::<PendingReviewContext>()
else {
return Ok(());
};
let [TurnInput::UserInput { content, .. }] = input else {
return Err(CodexErr::InvalidRequest(
"Guardian expects one review input".to_owned(),
));
};
let context = pending.0.clone();
let model = &step.settings.model_info;
let history = session.clone_history().await;
let prompt = build_prompt(
history.for_prompt(&model.input_modalities),
step,
session.get_prompt_base_instructions().await,
);
let request = session.services.model_client.build_responses_request(
&prompt,
model,
/*effort*/ None,
ReasoningSummary::None,
/*service_tier*/ None,
&session
.responses_metadata(&step.turn, CodexResponsesRequestKind::Turn)
.await,
)?;
let mut existing = super::request_budget::estimate_request_tokens(&request)
.max(usize::try_from(session.get_total_token_usage().await).unwrap_or(usize::MAX));
// These reminders are appended after the accepted input. Reserve their full
// serialized cost before choosing optional evidence, even if the time
// reminder's interval ultimately suppresses it.
if step
.turn
.config
.features
.enabled(Feature::CurrentTimeReminder)
&& step.turn.config.current_time_reminder.is_some()
{
let reminder = ContextualUserFragment::into(crate::context::CurrentTimeReminder::new(
chrono::Utc::now(),
));
existing = existing.saturating_add(
usize::try_from(estimate_item_token_count(&reminder)).unwrap_or(usize::MAX),
);
}
if let Some(reminder) = session
.services
.agent_control
.rollout_budget()
.pending_reminder(session.thread_id(), &session.current_window_id().await)
{
let reminder = ContextualUserFragment::into(crate::context::RolloutBudgetContext {
remaining_tokens: reminder.remaining_tokens,
});
existing = existing.saturating_add(
usize::try_from(estimate_item_token_count(&reminder)).unwrap_or(usize::MAX),
);
}
// Reserve the real input annotations as well as the shared content cost.
// Removing optional items can only reduce this metadata. The remaining
// margin covers IDs and timestamps assigned when recording the message.
let mut framing = session.response_item_from_user_input(content.clone());
if let ResponseItem::Message { content, .. } = &mut framing {
content.clear();
}
let budget = RequestBudget {
max_input_tokens: effective_input_token_limit(model, step.turn.config.model_context_window)
.saturating_sub(super::request_budget::INPUT_TOKEN_MARGIN),
existing_context_tokens: existing.saturating_add(
usize::try_from(estimate_item_token_count(&framing)).unwrap_or(usize::MAX),
),
};
let context = context
.enforce_budget(budget, GuardianBudgetOmission.render())
.map_err(|error| {
session
.services
.thread_extension_data
.insert(super::request_budget::ExhaustedReviewBudget);
match error {
codex_guardian_context::SectionError::EvidenceLimitExceeded { .. } => {
CodexErr::ContextWindowExceeded
}
error => CodexErr::InvalidRequest(error.to_string()),
}
})?;
for (section, cost) in context.section_costs() {
for (measurement, value) in cost.measurements() {
session
.services
.session_telemetry
.histogram_with_boundaries(
codex_guardian_context::SECTION_COST_METRIC,
i64::try_from(value).unwrap_or(i64::MAX),
codex_guardian_context::SECTION_COST_BOUNDARIES,
&[
("target", "sync"),
("section", section),
("measurement", measurement),
],
);
}
}
*content = context
.into_user_inputs()
.map_err(|error| CodexErr::InvalidRequest(error.to_string()))?;
session
.services
.thread_extension_data
.remove::<PendingReviewContext>();
session
.services
.thread_extension_data
.remove::<super::request_budget::ExhaustedReviewBudget>();
Ok(())
}
#[cfg(test)]
#[path = "input_budget_tests.rs"]
mod tests;
@@ -0,0 +1,138 @@
//! Exercises reviewer history safety at cancellation and budget boundaries.
use super::*;
use codex_guardian_context::ContextPresentation;
use codex_guardian_context::ContextProfile;
use codex_guardian_context::PlannedAction;
use codex_guardian_context::PlannedActionKind;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::TurnAbortReason;
use std::sync::Arc;
fn required_context(text: String) -> ComposedContext {
let action = PlannedAction {
json: text,
kind: PlannedActionKind::Command,
reason: None,
};
let context = super::super::prompt::collect_guardian_context(
&Vec::<ResponseItem>::new(),
super::super::GUARDIAN_MAX_TOOL_ENTRY_TOKENS,
&[],
&[],
Some(&action),
/*permissions*/ None,
/*node_repl*/ None,
)
.expect("collect required context");
let transcript = ContextProfile::synchronous()
.render_transcript(context.transcript_entries(), /*entry_number_offset*/ 0);
context
.compose(
ContextPresentation::SyncFull {
session_id: "test-parent",
},
transcript,
)
.expect("compose required context")
}
#[tokio::test]
async fn cancelled_startup_does_not_record_unselected_review_evidence() {
let (session, turn, events) = crate::session::tests::make_session_and_context_with_rx().await;
let context = required_context("unselected review evidence ".repeat(/*n*/ 10_000));
let content = context.clone().into_user_inputs().unwrap();
session
.services
.thread_extension_data
.insert(PendingReviewContext(context));
session
.set_session_startup_prewarm(
crate::session_startup_prewarm::SessionStartupPrewarmHandle::new(
tokio::spawn(std::future::pending()),
std::time::Instant::now(),
crate::client::WEBSOCKET_CONNECT_TIMEOUT,
),
)
.await;
session
.spawn_task(
turn,
vec![TurnInput::UserInput {
acceptance_order: None,
content,
client_id: None,
}],
crate::tasks::RegularTask::new(),
)
.await;
let started = tokio::time::timeout(std::time::Duration::from_secs(5), events.recv())
.await
.unwrap()
.unwrap();
assert!(matches!(started.msg, EventMsg::TurnStarted(_)));
session.abort_all_tasks(TurnAbortReason::Interrupted).await;
let history = session.clone_history().await;
let recorded = history.raw_items().collect::<Vec<_>>();
assert!(
!serde_json::to_string(&recorded)
.unwrap()
.contains("unselected review evidence")
);
assert!(
session
.services
.thread_extension_data
.get::<PendingReviewContext>()
.is_some()
);
}
#[tokio::test]
async fn feasibility_rejects_required_evidence_inside_the_reserved_margin() {
let (session, mut turn) = crate::session::tests::make_session_and_context().await;
let context = required_context("required action".to_owned());
let base = session.get_prompt_base_instructions().await;
let prefix = codex_protocol::protocol::TruncationPolicy::Bytes(base.text.len()).token_budget();
let model = Arc::make_mut(&mut Arc::make_mut(&mut turn.initial_settings).model_info);
model.effective_context_window_percent = 100;
Arc::make_mut(&mut turn.config).model_context_window =
Some(i64::try_from(context.estimated_tokens() + prefix + 128).unwrap());
session
.services
.thread_extension_data
.insert(PendingReviewContext(context));
assert!(check_pending(&session, &turn).await.is_err());
}
#[tokio::test]
async fn finalization_overflow_marks_the_reviewer_exhausted() {
let (session, mut turn) = crate::session::tests::make_session_and_context().await;
Arc::make_mut(&mut turn.config).model_context_window = Some(1);
let session = Arc::new(session);
let step = session
.capture_step_context(Arc::new(turn), &tokio_util::sync::CancellationToken::new())
.await
.unwrap();
let context = required_context("required action".to_owned());
let mut input = vec![TurnInput::UserInput {
acceptance_order: None,
content: context.clone().into_user_inputs().unwrap(),
client_id: None,
}];
session
.services
.thread_extension_data
.insert(PendingReviewContext(context));
assert!(finalize(&session, &step, &mut input).await.is_err());
assert!(
session
.services
.thread_extension_data
.get::<super::super::request_budget::ExhaustedReviewBudget>()
.is_some()
);
}
+6
View File
@@ -6,9 +6,15 @@ mod approval_request;
mod coverage;
mod decision;
mod feedback;
mod input_budget;
mod metrics;
mod prompt;
pub(crate) use input_budget::PendingReviewContext;
pub(crate) use input_budget::check_pending as check_pending_guardian_input;
pub(crate) use input_budget::finalize as finalize_guardian_input;
mod request_budget;
pub(crate) use request_budget::ExhaustedReviewBudget;
pub(crate) use request_budget::check_prompt as check_guardian_prompt_budget;
pub(crate) use request_budget::observe as observe_guardian_request;
mod review;
mod review_session;
+3 -21
View File
@@ -1,6 +1,7 @@
use codex_extension_api::ConversationHistorySnapshot;
use codex_guardian_context::Budgeted;
use codex_guardian_context::CollectedContext;
use codex_guardian_context::ComposedContext;
use codex_guardian_context::ContextPresentation;
use codex_guardian_context::ContextProfile;
#[cfg(test)]
@@ -14,7 +15,6 @@ use codex_guardian_context::SectionHistory;
use codex_guardian_context::SectionInput;
use codex_guardian_context::default_registry;
use codex_protocol::models::ResponseItem;
use codex_protocol::user_input::UserInput;
use crate::context::GuardianReviewEvidence;
use crate::context::NodeReplReviewEvidence;
@@ -37,7 +37,7 @@ const GUARDIAN_MAX_APPROVAL_REASON_TOKENS: usize = 512;
pub(super) const GUARDIAN_TRANSCRIPT_START: &str = ">>> TRANSCRIPT START\n";
pub(crate) struct GuardianPromptItems {
pub(crate) items: Vec<UserInput>,
pub(crate) context: ComposedContext,
pub(crate) transcript_cursor: GuardianTranscriptCursor,
pub(crate) node_repl_evidence_sequence: u64,
pub(crate) reviewed_action_truncated: bool,
@@ -214,26 +214,8 @@ pub(crate) async fn build_guardian_prompt_items_with_parent_turn(
.push(Budgeted::required(placeholder.to_owned()));
}
let context = sections.compose(presentation, transcript)?;
for (section, cost) in context.section_costs() {
for (measurement, value) in cost.measurements() {
session
.services
.session_telemetry
.histogram_with_boundaries(
codex_guardian_context::SECTION_COST_METRIC,
i64::try_from(value).unwrap_or(i64::MAX),
codex_guardian_context::SECTION_COST_BOUNDARIES,
&[
("target", "sync"),
("section", section),
("measurement", measurement),
],
);
}
}
let items = context.into_user_inputs()?;
Ok(GuardianPromptItems {
items,
context,
transcript_cursor,
node_repl_evidence_sequence,
reviewed_action_truncated: planned_action_json.truncated,
+67 -17
View File
@@ -1,28 +1,28 @@
//! Measures the complete synchronous request after image admission and wire
//! prefix assembly. Includes reused history, tool definitions and output format.
//! Measures and checks complete synchronous requests after wire prefix assembly.
//! Includes reused history, tool definitions, output format and continuations.
use codex_api::ResponsesApiRequest;
use codex_guardian_context::REQUEST_TOKENS_BOUNDARIES;
use codex_guardian_context::REQUEST_TOKENS_METRIC;
use codex_guardian_context::effective_input_token_limit;
use codex_otel::SessionTelemetry;
use codex_protocol::error::CodexErr;
use codex_protocol::error::Result as CodexResult;
use codex_protocol::openai_models::ModelInfo;
use codex_protocol::protocol::TruncationPolicy;
use crate::config::Config;
use crate::context_manager::estimate_item_token_count;
use codex_api::ResponsesApiRequest;
use codex_otel::SessionTelemetry;
use crate::session::session::Session;
pub(super) const INPUT_TOKEN_MARGIN: usize = 256;
// Keep a failed reviewer out of reuse unless compaction and a fresh budget
// check succeed. Also distinguishes local budget failures from backend errors.
pub(crate) struct ExhaustedReviewBudget;
pub(crate) fn observe(telemetry: &SessionTelemetry, request: &ResponsesApiRequest) -> usize {
let input = request
.input
.iter()
.map(estimate_item_token_count)
.fold(0i64, i64::saturating_add);
let instructions = TruncationPolicy::Bytes(request.instructions.len()).token_budget();
let metadata = serde_json::to_vec(&(&request.tools, &request.text))
.map(|bytes| TruncationPolicy::Bytes(bytes.len()).token_budget())
.unwrap_or(usize::MAX);
let total = usize::try_from(input)
.unwrap_or(usize::MAX)
.saturating_add(instructions)
.saturating_add(metadata);
let total = estimate_request_tokens(request);
// The assembled input already includes inherited history and the current
// review. Do not report a guessed old/new split after context injection.
telemetry.histogram_with_boundaries(
@@ -33,3 +33,53 @@ pub(crate) fn observe(telemetry: &SessionTelemetry, request: &ResponsesApiReques
);
total
}
pub(super) fn estimate_request_tokens(request: &ResponsesApiRequest) -> usize {
let input = request
.input
.iter()
.map(estimate_item_token_count)
.fold(0i64, i64::saturating_add);
let instructions = TruncationPolicy::Bytes(request.instructions.len()).token_budget();
let metadata = serde_json::to_vec(&(&request.tools, &request.text))
.map(|bytes| TruncationPolicy::Bytes(bytes.len()).token_budget())
.unwrap_or(usize::MAX);
usize::try_from(input)
.unwrap_or(usize::MAX)
.saturating_add(instructions)
.saturating_add(metadata)
}
/// Checks the fully assembled prompt after turn context has been injected. This
/// final guard also covers retries and reviewer tool continuations.
pub(crate) fn check_prompt(
session: &Session,
prompt: &crate::client_common::Prompt,
config: &Config,
model: &ModelInfo,
metadata: &crate::responses_metadata::CodexResponsesMetadata,
) -> CodexResult<()> {
let request = session.services.model_client.build_responses_request(
prompt,
model,
/*effort*/ None,
codex_protocol::config_types::ReasoningSummary::None,
/*service_tier*/ None,
metadata,
)?;
if estimate_request_tokens(&request)
> effective_input_token_limit(model, config.model_context_window)
.saturating_sub(INPUT_TOKEN_MARGIN)
{
session
.services
.thread_extension_data
.insert(ExhaustedReviewBudget);
return Err(CodexErr::ContextWindowExceeded);
}
session
.services
.thread_extension_data
.remove::<ExhaustedReviewBudget>();
Ok(())
}
+45 -16
View File
@@ -512,9 +512,9 @@ async fn run_review_on_session(
.await?;
if prompt_items
.items
.iter()
.any(|item| matches!(item, UserInput::Image { .. }))
.context
.section_costs()
.any(|(_, cost)| cost.image_count > 0)
{
let reviewer_history = review_session.session.clone_history().await;
let reviewer_image_urls = reviewer_history
@@ -548,10 +548,7 @@ async fn run_review_on_session(
} else {
ImagePreparationMode::DetailBased
};
prompt_items.items.retain_mut(|item| {
let UserInput::Image { detail, .. } = item else {
return true;
};
prompt_items.context.retain_images(|image_url, detail| {
*detail = match normalize_output_image_detail(&model_info, *detail) {
_ if mode == ImagePreparationMode::UnifiedBudget => {
Some(ImageDetail::Original)
@@ -559,7 +556,13 @@ async fn run_review_on_session(
Some(ImageDetail::Low) => Some(ImageDetail::High),
detail => detail,
};
let mut prepared = vec![ResponseInputItem::from(vec![item.clone()]).into()];
let mut prepared = vec![
ResponseInputItem::from(vec![UserInput::Image {
image_url: image_url.to_owned(),
detail: *detail,
}])
.into(),
];
prepare_response_items(
&mut prepared,
mode,
@@ -574,7 +577,8 @@ async fn run_review_on_session(
})
});
let prompt: ResponseItem =
ResponseInputItem::from(prompt_items.items.clone()).into();
ResponseInputItem::from(prompt_items.context.clone().into_user_inputs()?)
.into();
let prompt_tokens = crate::context_manager::estimate_item_token_count(&prompt);
let base_instructions = review_session.session.get_base_instructions().await;
let history_tokens = reviewer_history
@@ -587,13 +591,12 @@ async fn run_review_on_session(
false
};
if !admit_images {
prompt_items
.items
.retain(|item| !matches!(item, UserInput::Image { .. }));
prompt_items.context.retain_images(|_, _| false);
}
}
Ok::<_, anyhow::Error>(prompt_items)
let items = prompt_items.context.clone().into_user_inputs()?;
Ok::<_, anyhow::Error>((prompt_items, items))
}),
)
.await;
@@ -601,7 +604,7 @@ async fn run_review_on_session(
Ok(prompt_items) => prompt_items,
Err(outcome) => return (outcome, false, analytics_result),
};
let prompt_items = match prompt_items {
let (prompt_items, items) = match prompt_items {
Ok(prompt_items) => prompt_items,
Err(err) => {
return (
@@ -652,8 +655,15 @@ async fn run_review_on_session(
.unwrap_or_else(|| params.parent_context.turn().config.cwd.clone());
let parent_turn = params.parent_context.turn();
review_session
.session
.services
.thread_extension_data
.insert(super::input_budget::PendingReviewContext(
prompt_items.context,
));
let submission = review_session.io.submit_turn_input(
TurnInputRequest::user_input(prompt_items.items)
TurnInputRequest::user_input(items)
.with_thread_settings(codex_protocol::protocol::ThreadSettingsOverrides {
environments: Some(codex_protocol::protocol::TurnEnvironmentSelections::new(
parent_turn_legacy_fallback_cwd,
@@ -696,6 +706,13 @@ async fn run_review_on_session(
Box::pin(submission),
)
.await;
if !matches!(&submit_result, Ok(Ok(TurnInputSubmission::Started { .. }))) {
review_session
.session
.services
.thread_extension_data
.remove::<super::input_budget::PendingReviewContext>();
}
let child_turn_id = match submit_result {
Ok(Ok(TurnInputSubmission::Started { turn_id })) => turn_id,
Ok(Ok(submission)) => {
@@ -737,6 +754,11 @@ async fn run_review_on_session(
&mut analytics_result,
)
.await;
review_session
.session
.services
.thread_extension_data
.remove::<super::input_budget::PendingReviewContext>();
if matches!(outcome.0, GuardianReviewSessionOutcome::Completed(_)) {
if outcome.2
&& let Some(total_token_usage) = review_session.session.total_token_usage().await
@@ -750,7 +772,14 @@ async fn run_review_on_session(
state.prior_review_count = state.prior_review_count.saturating_add(1);
state.last_reviewed_transcript_cursor = Some(transcript_cursor);
}
(outcome.0, outcome.1, analytics_result)
let keep_review_session = outcome.1
&& review_session
.session
.services
.thread_extension_data
.remove::<super::request_budget::ExhaustedReviewBudget>()
.is_none();
(outcome.0, keep_review_session, analytics_result)
}
async fn ensure_guardian_followup_reminder(review_session: &GuardianReviewSession) {
+14 -13
View File
@@ -423,7 +423,7 @@ async fn build_guardian_prompt_full_mode_preserves_initial_review_format() -> an
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("whose request action you are assessing"));
assert!(text.contains(">>> TRANSCRIPT START\n"));
assert!(text.contains(">>> TRANSCRIPT END\n"));
@@ -464,7 +464,7 @@ async fn build_guardian_prompt_prefers_retry_reason_over_approval_reason() -> an
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("Retry reason:\nThe sandbox blocked the initial command.\n\n"));
assert!(!text.contains("A policy rule requires approval."));
@@ -506,8 +506,8 @@ async fn build_guardian_prompt_truncates_oversized_approval_reason() -> anyhow::
)
.await?;
let reason_item = prompt
.items
let items = prompt.context.into_user_inputs()?;
let reason_item = items
.iter()
.find_map(|item| match item {
codex_protocol::user_input::UserInput::Text { text, .. }
@@ -600,7 +600,7 @@ async fn build_guardian_prompt_includes_parent_turn_denied_reads() -> anyhow::Re
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("PARENT TURN PERMISSION CONTEXT START"));
assert!(text.contains("do not approve escalation whose purpose is to read them"));
assert!(text.contains(denied_root.to_string_lossy().as_ref()));
@@ -664,7 +664,7 @@ async fn build_guardian_prompt_delta_mode_preserves_original_numbering() -> anyh
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("added since your last approval assessment"));
assert!(text.contains(">>> TRANSCRIPT DELTA START\n"));
assert!(text.contains("[5] user: Please also push the second docs fix."));
@@ -705,7 +705,7 @@ async fn build_guardian_prompt_delta_mode_handles_empty_delta() -> anyhow::Resul
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains(">>> TRANSCRIPT DELTA START\n"));
assert!(text.contains("<no retained transcript delta entries>"));
assert!(text.contains(">>> TRANSCRIPT DELTA END\n"));
@@ -743,7 +743,7 @@ async fn build_guardian_prompt_stale_delta_cursor_falls_back_to_full_prompt() ->
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("whose request action you are assessing"));
assert!(text.contains(">>> TRANSCRIPT START\n"));
assert!(!text.contains("TRANSCRIPT DELTA"));
@@ -832,7 +832,7 @@ async fn build_guardian_prompt_stale_delta_version_falls_back_to_full_prompt() -
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("whose request action you are assessing"));
assert!(text.contains(">>> TRANSCRIPT START\n"));
assert!(!text.contains("TRANSCRIPT DELTA"));
@@ -1239,7 +1239,7 @@ async fn build_guardian_prompt_items_keeps_required_node_repl_reviews_generic()
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("Assess the exact planned action below."));
assert!(text.contains("Retry reason:\nRetry the authorized browser inspection."));
assert!(text.contains("Planned action JSON:"));
@@ -1275,7 +1275,7 @@ async fn build_guardian_prompt_items_keeps_other_requests_generic() -> anyhow::R
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("Assess the exact planned action below."));
assert!(text.contains("Planned action JSON:"));
assert!(!text.contains("Node REPL action JSON:"));
@@ -1360,7 +1360,7 @@ async fn build_guardian_prompt_items_explains_network_access_review_scope() -> a
)
.await?;
let text = guardian_prompt_text(&prompt.items);
let text = guardian_prompt_text(&prompt.context.into_user_inputs()?);
assert!(text.contains("Below is a proposed network access request under review."));
assert!(!text.contains("Network approval context:"));
assert!(
@@ -2330,7 +2330,8 @@ async fn build_guardian_prompt_items_includes_parent_session_id() -> anyhow::Res
)
.await?;
let prompt_text = prompt
.items
.context
.into_user_inputs()?
.into_iter()
.map(|item| match item {
codex_protocol::user_input::UserInput::Text { text, .. } => text,