Lightweight coding agent that runs in your terminal
Rust
Evict guardian transcript entries in cacheable chunks (#39315)
jif8ae72a9314dd
diff --git a/codex-rs/ext/guardian-v2/src/transcript.rs b/codex-rs/ext/guardian-v2/src/transcript.rsindex bae1bb6049..b1bd5718a9 100644--- a/codex-rs/ext/guardian-v2/src/transcript.rs+++ b/codex-rs/ext/guardian-v2/src/transcript.rs@@ -34,6 +34,37 @@ struct TranscriptEntry {tokens: usize,}+fn retained_tokens(+ entries: &[TranscriptEntry],+ retained: &VecDeque<usize>,+ kind: TranscriptEntryKind,+) -> usize {+ retained+ .iter()+ .filter_map(|&index| {+ let entry = &entries[index];+ (entry.kind == kind).then_some(entry.tokens)+ })+ .sum()+}++fn evict_oldest_matching(+ entries: &[TranscriptEntry],+ retained: &mut VecDeque<usize>,+ count: usize,+ mut matches: impl FnMut(TranscriptEntryKind) -> bool,+) {+ let mut remaining = count;+ retained.retain(|&index| {+ if remaining > 0 && matches(entries[index].kind) {+ remaining -= 1;+ false+ } else {+ true+ }+ });+}+#[derive(Clone, Debug, Eq, PartialEq)]pub(crate) struct TranscriptConfig {pub(crate) sources: Vec<TranscriptSource>,@@ -288,7 +319,6 @@ impl TranscriptConfig {let mut included = vec![false; entries.len()];let mut message_tokens = 0;- let mut tool_tokens = 0;let user_indices = entries.iter().enumerate()@@ -320,34 +350,67 @@ impl TranscriptConfig {message_tokens += entries[index].tokens;}- let mut retained_non_user_entries = 0;- for (index, entry) in entries.iter().enumerate().rev() {- if entry.kind == TranscriptEntryKind::User- || retained_non_user_entries >= self.max_recent_non_user_entries- {+ let available_message_tokens = self+ .max_message_transcript_tokens+ .saturating_sub(message_tokens);+ let mut retained_non_user = VecDeque::new();++ // Replay the transcript as an append-only bounded buffer. When a new entry would overflow+ // a budget, remove half of the existing entries in that pool before appending it. This+ // keeps the retained prefix stable between overflow points without storing sampler state.+ for (index, entry) in entries.iter().enumerate() {+ if entry.kind == TranscriptEntryKind::User {continue;}- let fits_budget = match entry.kind {- TranscriptEntryKind::Tool => {- tool_tokens + entry.tokens <= self.max_tool_transcript_tokens- }- TranscriptEntryKind::Message => {- message_tokens + entry.tokens <= self.max_message_transcript_tokens- }+ let token_budget = match entry.kind {+ TranscriptEntryKind::Tool => self.max_tool_transcript_tokens,+ TranscriptEntryKind::Message => available_message_tokens,TranscriptEntryKind::User => unreachable!("user entries were selected separately"),};- if !fits_budget {++ // An entry that cannot fit on its own must not evict retained evidence.+ if entry.tokens > token_budget || self.max_recent_non_user_entries == 0 {continue;}- included[index] = true;- retained_non_user_entries += 1;- match entry.kind {- TranscriptEntryKind::Tool => tool_tokens += entry.tokens,- TranscriptEntryKind::Message => message_tokens += entry.tokens,- TranscriptEntryKind::User => unreachable!("user entries were selected separately"),+ if retained_tokens(&entries, &retained_non_user, entry.kind)+ .saturating_add(entry.tokens)+ > token_budget+ {+ let retained_kind_count = retained_non_user+ .iter()+ .filter(|&&retained_index| entries[retained_index].kind == entry.kind)+ .count();+ evict_oldest_matching(+ &entries,+ &mut retained_non_user,+ retained_kind_count.div_ceil(2),+ |kind| kind == entry.kind,+ );+ while retained_tokens(&entries, &retained_non_user, entry.kind)+ .saturating_add(entry.tokens)+ > token_budget+ {+ evict_oldest_matching(+ &entries,+ &mut retained_non_user,+ /*count*/ 1,+ |kind| kind == entry.kind,+ );+ }}++ if retained_non_user.len().saturating_add(1) > self.max_recent_non_user_entries {+ let entries_to_evict = retained_non_user.len().div_ceil(2);+ evict_oldest_matching(&entries, &mut retained_non_user, entries_to_evict, |_| true);+ }++ retained_non_user.push_back(index);+ }++ for index in retained_non_user {+ included[index] = true;}entriesdiff --git a/codex-rs/ext/guardian-v2/src/transcript_tests.rs b/codex-rs/ext/guardian-v2/src/transcript_tests.rsindex 40a0640236..0da3d5f551 100644--- a/codex-rs/ext/guardian-v2/src/transcript_tests.rs+++ b/codex-rs/ext/guardian-v2/src/transcript_tests.rs@@ -261,6 +261,187 @@ fn transcript_reserves_separate_budget_for_recent_tool_evidence() {.sum::<usize>()<= MAX_TOOL_TRANSCRIPT_TOKENS);++ let first_retained_tool = tool_entries+ .first()+ .expect("at least one tool entry should be retained")+ .to_string();+ items.push(ResponseItem::FunctionCall {+ id: None,+ name: "exec_command".to_string(),+ namespace: None,+ arguments: format!("tool evidence 12: {}", "signal ".repeat(1_000)),+ encrypted_function_args: None,+ call_id: "call-12".to_string(),+ internal_chat_message_metadata_passthrough: None,+ });+ let next_transcript = TranscriptConfig::default().build(&items);+ let next_first_retained_tool = next_transcript+ .iter()+ .find(|entry| entry.contains("tool exec_command call:"))+ .expect("at least one tool entry should be retained");++ assert_eq!(next_first_retained_tool, &first_retained_tool);+ assert!(+ next_transcript+ .iter()+ .filter(|entry| entry.contains("tool exec_command call:"))+ .map(|entry| TruncationPolicy::Bytes(entry.len()).token_budget())+ .sum::<usize>()+ <= MAX_TOOL_TRANSCRIPT_TOKENS+ );+}++#[test]+fn transcript_preserves_newest_manual_approval_when_message_budget_overflows() {+ let older_text = "older assistant evidence ".repeat(20);+ let approval_text = format!(+ "{MANUAL_APPROVAL_DEVELOPER_PREFIX} {}",+ "approval details ".repeat(20)+ );+ let older_entry = format!("[1] assistant: {older_text}\n");+ let approval_entry = format!("[2] developer: {approval_text}\n");+ let message_budget = TruncationPolicy::Bytes(older_entry.len())+ .token_budget()+ .max(TruncationPolicy::Bytes(approval_entry.len()).token_budget());+ let items = vec![+ ResponseItem::Message {+ id: None,+ role: "assistant".to_string(),+ content: vec![ContentItem::OutputText { text: older_text }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ },+ ResponseItem::Message {+ id: None,+ role: "developer".to_string(),+ content: vec![ContentItem::InputText {+ text: approval_text,+ }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ },+ ];++ let transcript = TranscriptConfig {+ max_message_transcript_tokens: message_budget,+ ..TranscriptConfig::default()+ }+ .build(&items);++ assert_eq!(transcript, vec![approval_entry]);+}++#[test]+fn rejected_message_does_not_evict_retained_tool_entries() {+ let user_text = "Inspect the workspace.";+ let user_entry = format!("[1] user: {user_text}\n");+ let mut items = vec![ResponseItem::Message {+ id: None,+ role: "user".to_string(),+ content: vec![ContentItem::InputText {+ text: user_text.to_string(),+ }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ }];+ items.extend((0..40).map(|index| ResponseItem::FunctionCall {+ id: None,+ name: "exec_command".to_string(),+ namespace: None,+ arguments: format!("tool evidence {index}"),+ encrypted_function_args: None,+ call_id: format!("call-{index}"),+ internal_chat_message_metadata_passthrough: None,+ }));+ items.push(ResponseItem::Message {+ id: None,+ role: "assistant".to_string(),+ content: vec![ContentItem::OutputText {+ text: "This message has no remaining budget.".to_string(),+ }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ });+ let mut expected = vec![user_entry.clone()];+ expected.extend((0..40).map(|index| {+ format!(+ "[{}] tool exec_command call: tool evidence {index}\n",+ index + 2+ )+ }));++ let transcript = TranscriptConfig {+ max_message_transcript_tokens: TruncationPolicy::Bytes(user_entry.len()).token_budget(),+ ..TranscriptConfig::default()+ }+ .build(&items);++ assert_eq!(transcript, expected);+}++#[test]+fn transcript_evicts_non_user_entries_in_cacheable_chunks() {+ let config = TranscriptConfig {+ max_recent_non_user_entries: 4,+ ..TranscriptConfig::default()+ };+ let build_transcript = |tool_call_count| {+ let mut items = vec![ResponseItem::Message {+ id: None,+ role: "user".to_string(),+ content: vec![ContentItem::InputText {+ text: "Inspect the workspace.".to_string(),+ }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ }];+ items.extend(+ (0..tool_call_count).map(|index| ResponseItem::FunctionCall {+ id: None,+ name: "exec_command".to_string(),+ namespace: None,+ arguments: format!("tool evidence {index}"),+ encrypted_function_args: None,+ call_id: format!("call-{index}"),+ internal_chat_message_metadata_passthrough: None,+ }),+ );+ config.build(&items)+ };++ let first_overflow = build_transcript(5);+ let next_transcript = build_transcript(6);+ let second_overflow = build_transcript(7);++ assert_eq!(+ first_overflow,+ vec![+ "[1] user: Inspect the workspace.\n",+ "[4] tool exec_command call: tool evidence 2\n",+ "[5] tool exec_command call: tool evidence 3\n",+ "[6] tool exec_command call: tool evidence 4\n",+ ]+ );+ assert_eq!(+ next_transcript,+ vec![+ "[1] user: Inspect the workspace.\n",+ "[4] tool exec_command call: tool evidence 2\n",+ "[5] tool exec_command call: tool evidence 3\n",+ "[6] tool exec_command call: tool evidence 4\n",+ "[7] tool exec_command call: tool evidence 5\n",+ ]+ );+ assert_eq!(+ second_overflow,+ vec![+ "[1] user: Inspect the workspace.\n",+ "[6] tool exec_command call: tool evidence 4\n",+ "[7] tool exec_command call: tool evidence 5\n",+ "[8] tool exec_command call: tool evidence 6\n",+ ]+ );}#[test]