Lightweight coding agent that runs in your terminal
Rust
Budget retained images during remote compaction (#40280)
ashwinnathan-openai6677fd827d2c
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 8e124a5299..f8a17fe6d4 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -640,6 +640,9 @@"collaboration_modes": {"type": "boolean"},+ "compaction_image_budget": {+ "type": "boolean"+ },"computer_use": {"type": "boolean"},@@ -5610,6 +5613,9 @@"collaboration_modes": {"type": "boolean"},+ "compaction_image_budget": {+ "type": "boolean"+ },"computer_use": {"type": "boolean"},diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rsindex bfe995f074..b7cebf0b4d 100644--- a/codex-rs/core/src/compact_remote_v2.rs+++ b/codex-rs/core/src/compact_remote_v2.rs@@ -62,6 +62,15 @@ mod attempt;use attempt::RemoteCompactV2Attempt;use attempt::run_remote_compact_v2_attempt;+#[path = "compact_remote_v2_images.rs"]+mod images;++#[derive(Clone, Copy, PartialEq, Eq)]+enum RetainedImageBudget {+ Disabled,+ Enabled,+}+// Mirror the current /responses/compact retained-message default while the// server-side path remains the reference implementation.pub(crate) const RETAINED_MESSAGE_TOKEN_BUDGET: usize = 64_000;@@ -301,6 +310,11 @@ async fn run_remote_compact_task_inner_impl(prompt_input_metadata,compaction_output,sess.enabled(Feature::RetainClientDeveloperMessages),+ if sess.enabled(Feature::CompactionImageBudget) {+ RetainedImageBudget::Enabled+ } else {+ RetainedImageBudget::Disabled+ },);analytics_details.retained_image_count = Some(retained_images);let (new_window_number, new_window_ids) = sess.advance_auto_compact_window().await;@@ -463,6 +477,7 @@ fn build_v2_compacted_history(prompt_input_metadata: Vec<Option<CodexHarnessMetadata>>,compaction_output: ResponseItem,retain_client_developer_messages: bool,+ image_budget: RetainedImageBudget,) -> (Vec<ResponseItemEnvelope>, usize) {debug_assert_eq!(prompt_input.len(), prompt_input_metadata.len());let prompt_input = prompt_input@@ -480,7 +495,7 @@ fn build_v2_compacted_history(.flat_map(HistoryItemGroup::into_items).collect::<Vec<_>>();let mut retained =- truncate_retained_messages_for_remote_compaction(retained, RETAINED_MESSAGE_TOKEN_BUDGET);+ truncate_retained_messages(retained, RETAINED_MESSAGE_TOKEN_BUDGET, image_budget);let retained_image_count = retained.iter().map(|envelope| retained_input_image_count(&envelope.item))@@ -558,6 +573,14 @@ fn retained_input_image_count(item: &ResponseItem) -> usize {pub(crate) fn truncate_retained_messages_for_remote_compaction(items: Vec<ResponseItemEnvelope>,max_tokens: usize,+) -> Vec<ResponseItemEnvelope> {+ truncate_retained_messages(items, max_tokens, RetainedImageBudget::Disabled)+}++fn truncate_retained_messages(+ items: Vec<ResponseItemEnvelope>,+ max_tokens: usize,+ image_budget: RetainedImageBudget,) -> Vec<ResponseItemEnvelope> {let mut remaining = max_tokens;let mut truncated_reversed = Vec::with_capacity(items.len());@@ -571,14 +594,22 @@ pub(crate) fn truncate_retained_messages_for_remote_compaction(}let client_developer = is_client_authored_developer_message(&group.source);+ let charge_images = image_budget == RetainedImageBudget::Enabled && !client_developer;let notice_tokens = group.attached_notice.as_ref().map_or(0, |notice| message_text_token_count(¬ice.item).max(1));+ // Client-authored developer messages already charge non-text content via+ // the serialized estimate. Preserve their text-only boundary correction.+ let content_tokens = if charge_images {+ message_content_token_count(&group.source.item)+ } else {+ message_text_token_count(&group.source.item)+ };let source_tokens = if client_developer {usize::try_from(estimate_item_token_count(&group.source.item)).unwrap_or(usize::MAX)} else {- message_text_token_count(&group.source.item).max(1)+ content_tokens.max(1)};let token_count = source_tokens.saturating_add(notice_tokens);if token_count <= remaining {@@ -589,23 +620,30 @@ pub(crate) fn truncate_retained_messages_for_remote_compaction(remaining = remaining.saturating_sub(token_count);} else if remaining > notice_tokens {let available_tokens = remaining - notice_tokens;- let text_budget = if client_developer {- available_tokens.saturating_sub(- source_tokens.saturating_sub(message_text_token_count(&group.source.item)),- )+ let content_budget = if client_developer {+ available_tokens.saturating_sub(source_tokens.saturating_sub(content_tokens))} else {available_tokens};- let Some(mut truncated_item) =- truncate_message_text_to_token_budget(group.source, text_budget)- else {+ let image_count = retained_input_image_count(&group.source.item);+ if charge_images && image_count > 0 {+ // An oversized image can leave no boundary content. Do not backfill+ // the remaining budget with older messages in that case.+ remaining = 0;+ }+ let truncated_item = if charge_images && image_count > 0 {+ images::truncate_message_to_token_budget(group.source, content_budget)+ } else {+ truncate_message_text_to_token_budget(group.source, content_budget)+ };+ let Some(mut truncated_item) = truncated_item else {continue;};if client_developer {let item_tokens = usize::try_from(estimate_item_token_count(&truncated_item.item)).unwrap_or(usize::MAX);if item_tokens > available_tokens {- let adjusted_budget = text_budget+ let adjusted_budget = content_budget.saturating_sub(item_tokens - available_tokens).saturating_sub(1);let Some(adjusted) =@@ -627,12 +665,22 @@ pub(crate) fn truncate_retained_messages_for_remote_compaction(}truncated_reversed.push(truncated_item);remaining = 0;+ } else if charge_images && retained_input_image_count(&group.source.item) > 0 {+ remaining = 0;}}truncated_reversed.reverse();truncated_reversed}+fn message_content_token_count(item: &ResponseItem) -> usize {+ let ResponseItem::Message { content, .. } = item else {+ return usize::try_from(estimate_item_token_count(item)).unwrap_or(usize::MAX);+ };++ content.iter().map(images::content_item_token_count).sum()+}+fn message_text_token_count(item: &ResponseItem) -> usize {let ResponseItem::Message { content, .. } = item else {return usize::try_from(estimate_item_token_count(item)).unwrap_or(usize::MAX);@@ -718,7 +766,11 @@ mod tests {) -> (Vec<ResponseItemEnvelope>, usize) {let metadata = vec![None; input.len()];build_v2_compacted_history(- input, metadata, output, /*retain_client_developer_messages*/ false,+ input,+ metadata,+ output,+ /*retain_client_developer_messages*/ false,+ RetainedImageBudget::Disabled,)}@@ -829,6 +881,7 @@ mod tests {],output.clone(),enabled,+ RetainedImageBudget::Disabled,);let mut expected = vec![ResponseItemEnvelope {@@ -1132,3 +1185,7 @@ mod tests {);}}++#[cfg(test)]+#[path = "compact_remote_v2_image_budget_tests.rs"]+mod image_budget_tests;diff --git a/codex-rs/core/src/compact_remote_v2_image_budget_tests.rs b/codex-rs/core/src/compact_remote_v2_image_budget_tests.rsnew file mode 100644index 0000000000..30f44b952e--- /dev/null+++ b/codex-rs/core/src/compact_remote_v2_image_budget_tests.rs@@ -0,0 +1,162 @@+use super::*;+use codex_protocol::models::ContentItemKind;+use codex_protocol::models::InternalChatMessageMetadataPassthrough;+use codex_protocol::models::image_close_tag_text;+use codex_protocol::models::local_image_open_tag_text_with_path;+use pretty_assertions::assert_eq;++fn message(content: Vec<ContentItem>) -> ResponseItem {+ ResponseItem::Message {+ id: None,+ role: "user".to_string(),+ content,+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ }+}++fn image() -> ContentItem {+ ContentItem::InputImage {+ image_url: "data:image/png;base64,abc".to_string(),+ detail: None,+ }+}++fn text(value: &str) -> ContentItem {+ ContentItem::InputText {+ text: value.to_string(),+ }+}++fn trim(items: Vec<ResponseItem>, max_tokens: usize) -> Vec<ResponseItem> {+ truncate_retained_messages(+ items.into_iter().map(ResponseItemEnvelope::new).collect(),+ max_tokens,+ RetainedImageBudget::Enabled,+ )+ .into_iter()+ .map(ResponseItemEnvelope::into_item)+ .collect()+}++#[test]+fn image_only_boundary_is_atomic_and_does_not_backfill_older_messages() {+ let newest = message(vec![text("new")]);+ let items = vec![+ message(vec![text("old")]),+ message(vec![image()]),+ newest.clone(),+ ];+ let image_tokens = images::content_item_token_count(&image());+ for (max_tokens, expected) in [+ (+ image_tokens + 1,+ vec![message(vec![image()]), newest.clone()],+ ),+ (image_tokens, vec![newest.clone()]),+ (1, vec![newest]),+ ] {+ assert_eq!(trim(items.clone(), max_tokens), expected);+ }+}++#[test]+fn later_image_parts_preserve_labels_audio_and_annotations() {+ let parts = vec![+ text("earlier text"),+ text(&local_image_open_tag_text_with_path(+ /*label_number*/ 7,+ std::path::Path::new("image.png"),+ )),+ image(),+ text(&image_close_tag_text()),+ text("keep"),+ ContentItem::InputAudio {+ audio_url: "data:audio/wav;base64,abc".to_string(),+ },+ ];+ let kinds = (0..parts.len())+ .map(|i| ContentItemKind(format!("part.{i}")))+ .collect::<Vec<_>>();+ let mut source = message(parts.clone());+ let ResponseItem::Message {+ internal_chat_message_metadata_passthrough,+ ..+ } = &mut source+ else {+ unreachable!()+ };+ *internal_chat_message_metadata_passthrough = Some(InternalChatMessageMetadataPassthrough {+ turn_id: Some("turn-1".to_string()),+ content_item_kinds: Some(kinds.clone()),+ ..Default::default()+ });+ let image_tokens = parts[1..4]+ .iter()+ .map(images::content_item_token_count)+ .sum::<usize>();+ for (max_tokens, start) in [(image_tokens, 4), (image_tokens + 1, 1)] {+ let mut expected = source.clone();+ let ResponseItem::Message {+ content,+ internal_chat_message_metadata_passthrough,+ ..+ } = &mut expected+ else {+ unreachable!()+ };+ *content = parts[start..].to_vec();+ internal_chat_message_metadata_passthrough+ .as_mut()+ .unwrap()+ .content_item_kinds = Some(kinds[start..].to_vec());+ assert_eq!(trim(vec![source.clone()], max_tokens), vec![expected]);+ }+}++#[test]+fn image_treatment_preserves_text_only_boundary_behavior() {+ let source = ResponseItemEnvelope::new(message(vec![+ text("earlier text"),+ text(&"middle".repeat(20)),+ text("later text"),+ ContentItem::InputAudio {+ audio_url: "data:audio/wav;base64,abc".to_string(),+ },+ ]));+ for max_tokens in [0, 1, 4, 16, 100] {+ assert_eq!(+ truncate_retained_messages(+ vec![source.clone()],+ max_tokens,+ RetainedImageBudget::Enabled,+ ),+ truncate_retained_messages_for_remote_compaction(vec![source.clone()], max_tokens),+ );+ }+}++#[test]+fn image_treatment_preserves_client_developer_boundary_behavior() {+ let mut item = message(vec![image(), text(&"a".repeat(1000))]);+ let ResponseItem::Message { role, .. } = &mut item else {+ unreachable!()+ };+ *role = "developer".to_string();+ let source = ResponseItemEnvelope {+ item,+ metadata: Some(CodexHarnessMetadata {+ client_authored: true,+ }),+ };+ for max_tokens in [1871, 1879, 1880, 1950, 2200] {+ assert_eq!(+ truncate_retained_messages(+ vec![source.clone()],+ max_tokens,+ RetainedImageBudget::Enabled+ ),+ truncate_retained_messages_for_remote_compaction(vec![source.clone()], max_tokens),+ );+ }+}diff --git a/codex-rs/core/src/compact_remote_v2_images.rs b/codex-rs/core/src/compact_remote_v2_images.rsnew file mode 100644index 0000000000..d2fecb03a2--- /dev/null+++ b/codex-rs/core/src/compact_remote_v2_images.rs@@ -0,0 +1,100 @@+use crate::context_manager::estimate_image_bytes;+use codex_context_fragments::AnnotatedContent;+use codex_context_fragments::set_annotated_content;+use codex_context_fragments::to_annotated_content;+use codex_history::ResponseItemEnvelope;+use codex_protocol::models::ContentItem;+use codex_protocol::models::is_image_close_tag_text;+use codex_protocol::models::is_image_open_tag_text;+use codex_protocol::models::is_local_image_open_tag_text;+use codex_protocol::protocol::TruncationPolicy;+use codex_utils_output_truncation::approx_token_count;+use codex_utils_output_truncation::approx_tokens_from_byte_count_i64;+use codex_utils_output_truncation::truncate_text;++pub(super) fn content_item_token_count(item: &ContentItem) -> usize {+ match item {+ ContentItem::InputText { text } | ContentItem::OutputText { text } => {+ approx_token_count(text)+ }+ ContentItem::InputImage { image_url, detail } => usize::try_from(+ approx_tokens_from_byte_count_i64(estimate_image_bytes(image_url, *detail)),+ )+ .unwrap_or(usize::MAX),+ ContentItem::InputAudio { .. } => 0,+ }+}++/// Retain later parts of an image-containing boundary message, keeping each+/// image and its adjacent harness labels atomic. Text keeps its existing middle+/// truncation policy; audio remains uncharged and is preserved as before.+pub(super) fn truncate_message_to_token_budget(+ mut envelope: ResponseItemEnvelope,+ max_tokens: usize,+) -> Option<ResponseItemEnvelope> {+ let mut content = to_annotated_content(&mut envelope.item)?;+ let mut remaining = max_tokens;+ let mut retained = Vec::with_capacity(content.len());+ while !content.is_empty() {+ let last = content.len() - 1;+ let image_index = match content[last].content() {+ ContentItem::InputImage { .. } => Some(last),+ ContentItem::InputText { text }+ if is_image_close_tag_text(text)+ && last > 0+ && matches!(content[last - 1].content(), ContentItem::InputImage { .. }) =>+ {+ Some(last - 1)+ }+ _ => None,+ };+ if let Some(image_index) = image_index {+ let has_open_tag = image_index > 0+ && matches!(+ content[image_index - 1].content(),+ ContentItem::InputText { text }+ if is_local_image_open_tag_text(text) || is_image_open_tag_text(text)+ );+ let start = image_index - usize::from(has_open_tag);+ let token_count = content[start..]+ .iter()+ .map(AnnotatedContent::content)+ .map(content_item_token_count)+ .sum::<usize>();+ let fits = token_count <= remaining;+ remaining = if fits { remaining - token_count } else { 0 };+ for item in content.drain(start..).rev() {+ if fits {+ retained.push(item);+ }+ }+ continue;+ }+ let mut item = content.pop()?;+ match item.content_mut() {+ ContentItem::InputText { text } | ContentItem::OutputText { text } => {+ if remaining == 0 {+ continue;+ }+ let token_count = approx_token_count(text);+ if token_count <= remaining {+ remaining -= token_count;+ } else {+ *text = truncate_text(text, TruncationPolicy::Tokens(remaining));+ remaining = 0;+ }+ if !text.is_empty() {+ retained.push(item);+ }+ }+ ContentItem::InputAudio { .. } => retained.push(item),+ ContentItem::InputImage { .. } => unreachable!("images are handled atomically above"),+ }+ }+ if retained.is_empty() {+ return None;+ }+ retained.reverse();+ set_annotated_content(&mut envelope.item, retained)?;+ Some(envelope)+}diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rsindex 3d5914ec92..44cfad1995 100644--- a/codex-rs/core/src/compact_tests.rs+++ b/codex-rs/core/src/compact_tests.rs@@ -332,7 +332,9 @@ fn build_compacted_history_preserves_user_message_passthrough_metadata() {},metadata: Some(CodexHarnessMetadata::default()),},- ResponseItemEnvelope::new(user_message("summary text")),+ ResponseItemEnvelope::new(ContextualUserFragment::into(CompactionSummary::new(+ "summary text",+ ))),]);}diff --git a/codex-rs/core/src/context_manager/history.rs b/codex-rs/core/src/context_manager/history.rsindex cd5fc70394..98254ebc56 100644--- a/codex-rs/core/src/context_manager/history.rs+++ b/codex-rs/core/src/context_manager/history.rs@@ -769,6 +769,16 @@ fn estimate_original_image_bytes(image_url: &str) -> Option<i64> {})}+/// Shared image estimate, excluding the data URL prefix and message framing.+pub(crate) fn estimate_image_bytes(image_url: &str, detail: Option<ImageDetail>) -> i64 {+ match detail {+ Some(ImageDetail::Original) => {+ estimate_original_image_bytes(image_url).unwrap_or(RESIZED_IMAGE_BYTES_ESTIMATE)+ }+ _ => RESIZED_IMAGE_BYTES_ESTIMATE,+ }+}+/// Scans one response item for discount-eligible inline image data URLs and/// returns:/// - total base64 payload bytes to subtract from raw serialized size@@ -781,12 +791,8 @@ fn image_data_url_estimate_adjustment(item: &ResponseItem) -> (i64, i64) {if let Some(payload_len) = parse_base64_image_data_url(image_url).map(str::len) {payload_bytes =payload_bytes.saturating_add(i64::try_from(payload_len).unwrap_or(i64::MAX));- replacement_bytes = replacement_bytes.saturating_add(match detail {- Some(ImageDetail::Original) => {- estimate_original_image_bytes(image_url).unwrap_or(RESIZED_IMAGE_BYTES_ESTIMATE)- }- _ => RESIZED_IMAGE_BYTES_ESTIMATE,- });+ replacement_bytes =+ replacement_bytes.saturating_add(estimate_image_bytes(image_url, detail));}};diff --git a/codex-rs/core/src/context_manager/mod.rs b/codex-rs/core/src/context_manager/mod.rsindex f2bdd89c41..97cd7c2109 100644--- a/codex-rs/core/src/context_manager/mod.rs+++ b/codex-rs/core/src/context_manager/mod.rs@@ -3,6 +3,7 @@ mod normalize;pub(crate) mod updates;pub(crate) use history::ContextManager;+pub(crate) use history::estimate_image_bytes;pub(crate) use history::estimate_item_token_count;pub(crate) use history::is_user_turn_boundary;pub(crate) use history::truncate_function_output_payload;diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 1fa912cc1c..dfe2cea2b7 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -11215,9 +11215,7 @@ async fn sample_rollout(rollout_items.push(RolloutItem::ResponseItem(assistant1.clone().into()));let summary1 = "summary one";- let snapshot1 = live_history- .clone()- .for_prompt(&reconstruction_turn.model_info.input_modalities);+ let snapshot1 = raw_history_items(&live_history);let user_messages1 = collect_user_messages(&snapshot1);let rebuilt1 = compact::build_compacted_history(Vec::new(), &user_messages1, summary1);live_history.replace_annotated(rebuilt1);@@ -11263,9 +11261,7 @@ async fn sample_rollout(rollout_items.push(RolloutItem::ResponseItem(assistant2.clone().into()));let summary2 = "summary two";- let snapshot2 = live_history- .clone()- .for_prompt(&reconstruction_turn.model_info.input_modalities);+ let snapshot2 = raw_history_items(&live_history);let user_messages2 = collect_user_messages(&snapshot2);let rebuilt2 = compact::build_compacted_history(Vec::new(), &user_messages2, summary2);live_history.replace_annotated(rebuilt2);@@ -11310,10 +11306,7 @@ async fn sample_rollout();rollout_items.push(RolloutItem::ResponseItem(assistant3.into()));- (- rollout_items,- strip_metadata_from_items(&raw_history_items(&live_history)),- )+ (rollout_items, raw_history_items(&live_history))}#[tokio::test]diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rsindex 95a4db0a96..2a5c3f3aed 100644--- a/codex-rs/core/tests/suite/compact_remote.rs+++ b/codex-rs/core/tests/suite/compact_remote.rs@@ -1328,6 +1328,150 @@ async fn remote_manual_compact_chatgpt_auth_reuses_service_tier_and_prompt_cacheOk(())}+#[test_case(None; "default_preserves_images")]+#[test_case(Some(false); "disabled_preserves_images")]+#[test_case(Some(true); "enabled_trims_images")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn remote_compact_v2_charges_retained_images_to_token_budget(+ image_budget_enabled: Option<bool>,+) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let harness = TestCodexHarness::with_auto_env_builder(+ test_codex()+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_config(move |config| {+ let _ = config.features.enable(Feature::RemoteCompactionV2);+ let _ = config.features.enable(Feature::UnifiedImageBudget);+ if let Some(enabled) = image_budget_enabled {+ let _ = config+ .features+ .set_enabled(Feature::CompactionImageBudget, enabled);+ }+ }),+ )+ .await?;+ let codex = &harness.test().codex;+ // Each original-detail image costs 10,000 estimated patch tokens.+ let image_inputs = (1..=8)+ .map(|number| {+ let image = image::ImageBuffer::from_pixel(+ /*width*/ 3200,+ /*height*/ 3200,+ image::Luma([number as u8]),+ );+ let mut bytes = std::io::Cursor::new(Vec::new());+ image.write_to(&mut bytes, image::ImageFormat::Png)?;+ Ok(UserInput::Image {+ image_url: format!(+ "data:image/png;base64,{}",+ BASE64_STANDARD.encode(bytes.get_ref())+ ),+ detail: Some(codex_protocol::models::ImageDetail::Original),+ })+ })+ .collect::<Result<Vec<_>>>()?;+ let mut input = image_inputs[..7].to_vec();+ input.push(UserInput::Text {+ text: "Compare these images".to_string(),+ text_elements: Vec::new(),+ });+ let initial_mock = mount_sse_once(+ harness.server(),+ sse(vec![+ responses::ev_assistant_message("initial", "done"),+ responses::ev_completed("initial"),+ ]),+ )+ .await;+ codex+ .start_or_steer_turn(TurnInputRequest::user_input(input))+ .await?;+ wait_for_turn_complete(codex).await;+ let initial_request = initial_mock.single_request();+ let prepared_images = initial_request.message_input_image_urls("user");+ assert_eq!(prepared_images.len(), 7);++ for cycle in 1..=2 {+ let compact_mock = mount_sse_once(+ harness.server(),+ sse(vec![+ json!({+ "type": "response.output_item.done",+ "item": { "type": "compaction", "encrypted_content": "IMAGE_BUDGET_SUMMARY" },+ }),+ responses::ev_completed("compact-images"),+ ]),+ )+ .await;+ codex.submit(Op::Compact).await?;+ wait_for_turn_complete(codex).await;+ let compact_request = compact_mock.single_request();+ assert_eq!(compact_request.path(), "/v1/responses");+ assert_eq!(+ compact_request.inputs_of_type("compaction_trigger").len(),+ 1+ );++ let follow_up_mock = mount_sse_once(+ harness.server(),+ sse(vec![+ responses::ev_assistant_message("after", "done"),+ responses::ev_completed("after"),+ ]),+ )+ .await;+ codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "after compact".to_string(),+ text_elements: Vec::new(),+ }]))+ .await?;+ wait_for_turn_complete(codex).await;+ let follow_up = follow_up_mock.single_request();+ assert_eq!(+ follow_up.inputs_of_type("compaction")[0]["encrypted_content"],+ "IMAGE_BUDGET_SUMMARY"+ );+ let dropped = if image_budget_enabled == Some(true) {+ cycle+ } else {+ 0+ };+ let mut expected_images = prepared_images[dropped..].to_vec();+ if cycle == 2 {+ let UserInput::Image { image_url, .. } = &image_inputs[7] else {+ unreachable!()+ };+ expected_images.push(image_url.clone());+ }+ assert_eq!(follow_up.message_input_image_urls("user"), expected_images);+ assert!(+ follow_up+ .message_input_texts("user")+ .iter()+ .any(|text| text == "Compare these images")+ );++ if cycle == 1 {+ let append_mock = mount_sse_once(+ harness.server(),+ sse(vec![+ responses::ev_assistant_message("append", "done"),+ responses::ev_completed("append"),+ ]),+ )+ .await;+ codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![image_inputs[7].clone()]))+ .await?;+ wait_for_turn_complete(codex).await;+ let _ = append_mock.single_request();+ }+ }+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn remote_compact_v2_reuses_compaction_trigger_for_followups() -> Result<()> {skip_if_no_network!(Ok(()));diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rsindex 602ca711e7..af37ac20ad 100644--- a/codex-rs/features/src/lib.rs+++ b/codex-rs/features/src/lib.rs@@ -305,6 +305,8 @@ pub enum Feature {PreventIdleSleep,/// Enable remote compaction v2 over the normal Responses API.RemoteCompactionV2,+ /// Include retained images in the remote compaction context budget.+ CompactionImageBudget,/// Retain client-authored developer messages across compacted context windows.RetainClientDeveloperMessages,/// Use Agent Identity for ChatGPT-authenticated sessions.@@ -1545,6 +1547,12 @@ pub const FEATURES: &[FeatureSpec] = &[stage: Stage::Stable,default_enabled: true,},+ FeatureSpec {+ id: Feature::CompactionImageBudget,+ key: "compaction_image_budget",+ stage: Stage::UnderDevelopment,+ default_enabled: false,+ },FeatureSpec {id: Feature::RetainClientDeveloperMessages,key: "retain_client_developer_messages",