diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rs index 9d00c4ec19..4559e7d18c 100644 --- a/codex-rs/core/src/compact.rs +++ b/codex-rs/core/src/compact.rs @@ -772,8 +772,8 @@ fn build_compacted_history_with_limit( else { continue; }; + // A user already selected by retained_client_items is explicitly pinned. if selected.contains_key(&position) { - remaining = remaining.saturating_sub(tokens); continue; } let mut harness_metadata = message.harness_metadata.cloned(); diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rs index 01edab2141..ac0bef66ac 100644 --- a/codex-rs/core/src/compact_remote_v2.rs +++ b/codex-rs/core/src/compact_remote_v2.rs @@ -735,7 +735,7 @@ fn truncate_retained_messages( .collect() } -/// Select newest first, then return the items at their original positions. +/// Keep explicit pins whole, spend the carryover budget newest first, and restore source order. fn select_retained_items( items: &[ResponseItemEnvelope], should_retain: impl Fn(&ResponseItemEnvelope) -> bool, @@ -746,11 +746,19 @@ fn select_retained_items( ) -> BTreeMap { let mut remaining = max_tokens; let mut selected = BTreeMap::new(); + for group in newest_history_item_groups(items, is_pinned) { + if is_pinned(group.source) + && group.source.has_explicit_retention_pin() + && should_retain(group.source) + { + group.keep(&mut selected, group.source.clone()); + } + } for group in newest_history_item_groups(items, is_pinned) { if remaining == 0 { break; } - if !should_retain(group.source) { + if selected.contains_key(&group.source_position) || !should_retain(group.source) { continue; } @@ -778,7 +786,7 @@ fn select_retained_items( ) .max(1) }); - // Explicitly retained items and client developer messages also pay for their media. + // Feature-retained client items pay for their media. let content_tokens = retained_message_token_count(&group.source.item, image_budget, audio_durations); let source_tokens = if charge_full_item { @@ -1171,6 +1179,44 @@ mod tests { } } + #[test] + fn explicit_pins_survive_an_exhausted_budget_only_in_their_destination() { + use codex_protocol::turn_input::InjectedResponseItem; + use codex_protocol::turn_input::ItemRetention; + + let pin = |text, retention| { + ResponseItemEnvelope::from(InjectedResponseItem { + item: message("developer", text, /*phase*/ None), + retention, + }) + }; + let shared = pin("shared", ItemRetention::Always); + let thread = pin("thread", ItemRetention::AlwaysInThread); + let child = pin("child", ItemRetention::AlwaysInChildren); + let mut configured = pin("feature-retained developer log", ItemRetention::Unspecified); + configured + .metadata + .get_or_insert_default() + .retain_across_windows = Some(true); + let items = [shared.clone(), thread.clone(), child.clone(), configured]; + let in_child: fn(&ResponseItemEnvelope) -> bool = + |item| item.child_retention() == Some(true); + for (destination, expected) in [ + (in_child, [shared.clone(), child]), + (ResponseItemEnvelope::is_always_retained, [shared, thread]), + ] { + let selected = select_retained_items( + &items, + destination, + destination, + /*max_tokens*/ 0, + RetainedImageBudget::Disabled, + &FileAudioDurations::default(), + ); + assert_eq!(selected.into_values().collect::>(), expected); + } + } + #[test] fn retained_history_truncation_preserves_metadata() { let item = ResponseItemEnvelope { diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rs index 9efe51eaa8..b43c2b175e 100644 --- a/codex-rs/core/src/compact_tests.rs +++ b/codex-rs/core/src/compact_tests.rs @@ -661,6 +661,26 @@ fn build_token_limited_compacted_history_truncates_overlong_user_messages( assert_eq!(history[1].metadata, None); } +#[test] +fn local_compaction_keeps_an_ordinary_user_beside_a_pinned_user() { + use codex_protocol::turn_input::InjectedResponseItem; + use codex_protocol::turn_input::ItemRetention; + + let ordinary = ResponseItemEnvelope::new(user_message("abcd")); + let pin = ResponseItemEnvelope::from(InjectedResponseItem { + item: user_message("larger than the optional budget"), + retention: ItemRetention::AlwaysInThread, + }); + let items = [ordinary.clone(), pin.clone()]; + let compacted = build_compacted_history_with_limit( + &items, + "summary", + /*max_tokens*/ 1, + &FileAudioDurations::default(), + ); + assert_eq!(&compacted[..2], &[ordinary, pin]); +} + #[test] fn build_token_limited_compacted_history_appends_summary_message() { let items = annotated(vec![user_message("first user message")]); diff --git a/codex-rs/history/src/lib.rs b/codex-rs/history/src/lib.rs index 941315b32e..d681aee033 100644 --- a/codex-rs/history/src/lib.rs +++ b/codex-rs/history/src/lib.rs @@ -358,6 +358,28 @@ impl ResponseItemEnvelope { .or_else(|| metadata.retain_across_windows.filter(|retain| *retain)) } + /// An explicit injection policy exempts the item from the soft carryover budget + /// wherever its policy pins it. Older developer messages and named turn outputs + /// could also have been retained by a feature, so keep their historical pricing. + pub fn has_explicit_retention_pin(&self) -> bool { + let Some(metadata) = &self.metadata else { + return false; + }; + if metadata.retain_in_children.is_some() { + return true; + } + self.is_always_retained() + && match &self.item { + ResponseItem::Message { role, .. } => role != "developer", + ResponseItem::FunctionCallOutput { + name: Some(_), + call_id: None, + .. + } => false, + _ => true, + } + } + /// Wraps a raw Responses API item for persisted history. pub fn new(item: ResponseItem) -> Self { Self { @@ -384,7 +406,7 @@ impl From for ResponseItemEnvelope { let (across_windows, in_children) = match injected.retention { ItemRetention::Unspecified => return envelope, ItemRetention::Default => (false, None), - ItemRetention::Always => (true, None), + ItemRetention::Always => (true, Some(true)), ItemRetention::AlwaysInThread => (true, Some(false)), ItemRetention::AlwaysInChildren => (false, Some(true)), };