Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Share Guardian user-message retention logic (#42031)

felixxia-oai82099786163f
diff --git a/codex-rs/core/src/guardian/prompt.rs b/codex-rs/core/src/guardian/prompt.rs
index 8bbf5e6b37..b03ae6b0a7 100644
--- a/codex-rs/core/src/guardian/prompt.rs
+++ b/codex-rs/core/src/guardian/prompt.rs
@@ -398,45 +398,27 @@ fn render_guardian_transcript_entries_with_offset(
.collect::<Vec<_>>();
let mut included = vec![false; entries.len()];
- let mut message_tokens = 0usize;
- let mut tool_tokens = 0usize;
- let user_indices = entries
+ let user_messages = entries
.iter()
.enumerate()
.filter_map(|(index, entry)| {
- matches!(entry.kind, ConversationTranscriptEntryKind::User).then_some(index)
+ matches!(entry.kind, ConversationTranscriptEntryKind::User).then_some(
+ codex_guardian_context::UserMessageCost {
+ index,
+ tokens: rendered_entries[index].1,
+ },
+ )
})
.collect::<Vec<_>>();
-
- if let Some(&first_user_index) = user_indices.first() {
- included[first_user_index] = true;
- message_tokens += rendered_entries[first_user_index].1;
- }
-
- if let Some(&last_user_index) = user_indices.last()
- && !included[last_user_index]
- && message_tokens + rendered_entries[last_user_index].1
- <= GUARDIAN_TRANSCRIPT_RETENTION.max_message_transcript_tokens
- {
- included[last_user_index] = true;
- message_tokens += rendered_entries[last_user_index].1;
- }
-
- for &index in user_indices.iter().rev() {
- if included[index] {
- continue;
- }
-
- let token_count = rendered_entries[index].1;
- if message_tokens + token_count
- > GUARDIAN_TRANSCRIPT_RETENTION.max_message_transcript_tokens
- {
- continue;
- }
-
+ let selection = codex_guardian_context::select_user_messages(
+ &user_messages,
+ GUARDIAN_TRANSCRIPT_RETENTION.max_message_transcript_tokens,
+ );
+ for index in selection.indices {
included[index] = true;
- message_tokens += token_count;
}
+ let mut message_tokens = selection.tokens;
+ let mut tool_tokens = 0usize;
let mut retained_non_user_entries = 0usize;
for index in (0..entries.len()).rev() {
diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs b/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs
index 4c290a6507..9ba05637a0 100644
--- a/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs
+++ b/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs
@@ -225,41 +225,28 @@ impl TranscriptConfig {
}
let mut included = vec![false; entries.len()];
- let mut message_tokens = 0;
- let user_indices = entries
+ let user_messages = entries
.iter()
.enumerate()
- .filter_map(|(index, entry)| (entry.kind == TranscriptEntryKind::User).then_some(index))
+ .filter_map(|(index, entry)| {
+ (entry.kind == TranscriptEntryKind::User).then_some(
+ codex_guardian_context::UserMessageCost {
+ index,
+ tokens: entry.tokens,
+ },
+ )
+ })
.collect::<Vec<_>>();
-
- if let Some(&first_user_index) = user_indices.first() {
- included[first_user_index] = true;
- message_tokens += entries[first_user_index].tokens;
- }
-
- if let Some(&latest_user_index) = user_indices.last()
- && !included[latest_user_index]
- && message_tokens + entries[latest_user_index].tokens
- <= retention.max_message_transcript_tokens
- {
- included[latest_user_index] = true;
- message_tokens += entries[latest_user_index].tokens;
- }
-
- for &index in user_indices.iter().rev() {
- if included[index]
- || message_tokens + entries[index].tokens > retention.max_message_transcript_tokens
- {
- continue;
- }
-
+ let selection = codex_guardian_context::select_user_messages(
+ &user_messages,
+ retention.max_message_transcript_tokens,
+ );
+ for index in selection.indices {
included[index] = true;
- message_tokens += entries[index].tokens;
}
-
let available_message_tokens = retention
.max_message_transcript_tokens
- .saturating_sub(message_tokens);
+ .saturating_sub(selection.tokens);
let mut window = TranscriptWindow::new(&entries, retention, available_message_tokens);
for index in 0..entries.len() {
window.insert(index);
diff --git a/codex-rs/guardian-context/src/lib.rs b/codex-rs/guardian-context/src/lib.rs
index 052eee165c..3c1ae8090d 100644
--- a/codex-rs/guardian-context/src/lib.rs
+++ b/codex-rs/guardian-context/src/lib.rs
@@ -19,6 +19,9 @@ use transcript::ConversationTranscriptSection;
pub use entry::ConversationTranscriptEntry;
pub use entry::ConversationTranscriptEntryKind;
pub use history::TranscriptHistory;
+pub use retention::UserMessageCost;
+pub use retention::UserMessageSelection;
+pub use retention::select_user_messages;
pub use transcript::ConversationTranscriptConfig;
pub use transcript::ConversationTranscriptOptions;
pub use transcript::MANUAL_APPROVAL_DEVELOPER_PREFIX;
@@ -29,6 +32,7 @@ pub use truncation::truncate_text;
mod entry;
mod history;
+mod retention;
mod transcript;
mod truncation;
diff --git a/codex-rs/guardian-context/src/retention.rs b/codex-rs/guardian-context/src/retention.rs
new file mode 100644
index 0000000000..459db6138b
--- /dev/null
+++ b/codex-rs/guardian-context/src/retention.rs
@@ -0,0 +1,48 @@
+//! Shared user-message selection, independent of rendering and non-user eviction.
+//!
+//! Callers supply costs including their own formatting. The first user message
+//! remains an anchor even when it exceeds the budget, preserving existing behavior.
+
+/// Rendered cost and original transcript position of a genuine user message.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct UserMessageCost {
+ pub index: usize,
+ pub tokens: usize,
+}
+
+/// Selected original indices and their total rendered token cost.
+#[derive(Debug, Default, Eq, PartialEq)]
+pub struct UserMessageSelection {
+ pub indices: Vec<usize>,
+ pub tokens: usize,
+}
+
+/// Keeps the first and latest user messages, then fills from newest to oldest.
+///
+/// Supply messages in conversation order with distinct original indices. The
+/// returned indices are in selection order; callers render in conversation order.
+/// Non-user evidence uses the remaining budget under the caller's own policy.
+pub fn select_user_messages(
+ messages: &[UserMessageCost],
+ max_message_tokens: usize,
+) -> UserMessageSelection {
+ let Some((first, remaining)) = messages.split_first() else {
+ return UserMessageSelection::default();
+ };
+ let mut selection = UserMessageSelection {
+ indices: vec![first.index],
+ tokens: first.tokens,
+ };
+ // The latest message is considered first, including when it cannot fit.
+ for message in remaining.iter().rev() {
+ if selection.tokens.saturating_add(message.tokens) <= max_message_tokens {
+ selection.indices.push(message.index);
+ selection.tokens += message.tokens;
+ }
+ }
+ selection
+}
+
+#[cfg(test)]
+#[path = "retention_tests.rs"]
+mod tests;
diff --git a/codex-rs/guardian-context/src/retention_tests.rs b/codex-rs/guardian-context/src/retention_tests.rs
new file mode 100644
index 0000000000..a5095b5cc0
--- /dev/null
+++ b/codex-rs/guardian-context/src/retention_tests.rs
@@ -0,0 +1,48 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn user_selection_preserves_anchors_and_fills_from_newest() {
+ let messages = [
+ UserMessageCost {
+ index: 2,
+ tokens: 4,
+ },
+ UserMessageCost {
+ index: 5,
+ tokens: 3,
+ },
+ UserMessageCost {
+ index: 8,
+ tokens: 6,
+ },
+ UserMessageCost {
+ index: 10,
+ tokens: 2,
+ },
+ ];
+ for (budget, indices, tokens) in [
+ (0, vec![2], 4),
+ (4, vec![2], 4),
+ (6, vec![2, 10], 6),
+ (9, vec![2, 10, 5], 9),
+ (12, vec![2, 10, 8], 12),
+ (15, vec![2, 10, 8, 5], 15),
+ ] {
+ assert_eq!(
+ select_user_messages(&messages, budget),
+ UserMessageSelection { indices, tokens },
+ );
+ }
+ assert_eq!(
+ select_user_messages(&[], /*max_message_tokens*/ 10),
+ UserMessageSelection::default(),
+ );
+ assert_eq!(
+ select_user_messages(&messages[..1], /*max_message_tokens*/ 10),
+ UserMessageSelection {
+ indices: vec![2],
+ tokens: 4
+ },
+ );
+}