Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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;
}
entries
diff --git a/codex-rs/ext/guardian-v2/src/transcript_tests.rs b/codex-rs/ext/guardian-v2/src/transcript_tests.rs
index 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]