diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index f1422e1e0d..cf27ff4c56 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -20,6 +20,7 @@ use crate::apps::render_apps_section; use crate::commit_attribution::commit_message_trailer_instruction; use crate::compact; use crate::compact::InitialContextInjection; +use crate::compact::insert_initial_context_before_last_real_user_or_summary; use crate::compact::run_inline_auto_compact_task; use crate::compact::should_use_remote_compact_task; use crate::compact_remote::run_inline_remote_auto_compact_task; @@ -3242,8 +3243,10 @@ impl Session { history_before_turn: &[ResponseItem], ) { let current_history = self.clone_history().await; + let initial_context = self.build_initial_context(turn_context).await; let replacement_history = build_server_side_compaction_replacement_history( item.clone(), + initial_context, history_before_turn, current_history.raw_items(), ); @@ -5949,30 +5952,31 @@ struct PendingServerSideCompaction { fn build_server_side_compaction_replacement_history( compaction_item: ResponseItem, + initial_context: Vec, history_before_turn: &[ResponseItem], current_history: &[ResponseItem], ) -> Vec { let current_turn_items = current_history .strip_prefix(history_before_turn) + .or_else(|| current_history.strip_prefix(initial_context.as_slice())) .unwrap_or(current_history); - let current_turn_items = if matches!( - current_turn_items.first(), - Some(ResponseItem::Compaction { .. }) - ) { - let first_non_compaction = current_turn_items - .iter() - .position(|item| !matches!(item, ResponseItem::Compaction { .. })) - .unwrap_or(current_turn_items.len()); - ¤t_turn_items[first_non_compaction..] - } else { - current_turn_items - }; - let mut replacement_history = vec![compaction_item]; - replacement_history.extend( - current_turn_items - .iter() - .filter(|item| !matches!(item, ResponseItem::GhostSnapshot { .. })) - .cloned(), + let mut replacement_history: Vec = current_turn_items + .iter() + .filter(|item| !matches!(item, ResponseItem::GhostSnapshot { .. })) + .filter(|item| !matches!(item, ResponseItem::Compaction { .. })) + .filter(|item| match item { + ResponseItem::Message { role, .. } if role == "developer" => false, + ResponseItem::Message { role, content, .. } if role == "user" => { + !crate::event_mapping::is_contextual_user_message_content(content) + } + _ => true, + }) + .cloned() + .collect(); + replacement_history.push(compaction_item); + let mut replacement_history = insert_initial_context_before_last_real_user_or_summary( + replacement_history, + initial_context, ); replacement_history.extend( current_history diff --git a/codex-rs/core/src/codex_tests.rs b/codex-rs/core/src/codex_tests.rs index 4855698447..ade9511f9c 100644 --- a/codex-rs/core/src/codex_tests.rs +++ b/codex-rs/core/src/codex_tests.rs @@ -113,6 +113,30 @@ fn user_message(text: &str) -> ResponseItem { } } +fn developer_message(text: &str) -> ResponseItem { + ResponseItem::Message { + id: None, + role: "developer".to_string(), + content: vec![ContentItem::InputText { + text: text.to_string(), + }], + end_turn: None, + phase: None, + } +} + +fn environment_context_message(cwd: &str) -> ResponseItem { + ResponseItem::Message { + id: None, + role: "user".to_string(), + content: vec![ContentItem::InputText { + text: format!("\n{cwd}\n"), + }], + end_turn: None, + phase: None, + } +} + fn assistant_message(text: &str) -> ResponseItem { ResponseItem::Message { id: None, @@ -265,6 +289,10 @@ fn build_server_side_compaction_replacement_history_keeps_current_turn_inputs() let prior_snapshot = ghost_snapshot("ghost-before"); let same_turn_snapshot = ghost_snapshot("ghost-during"); let history_before_turn = vec![user_message("earlier"), prior_snapshot.clone()]; + let initial_context = vec![ + developer_message("fresh permissions"), + environment_context_message("/fresh"), + ]; let current_turn_user = user_message("current turn"); let current_turn_tool_output = ResponseItem::FunctionCallOutput { call_id: "call-1".to_string(), @@ -273,6 +301,8 @@ fn build_server_side_compaction_replacement_history_keeps_current_turn_inputs() let current_history = vec![ user_message("earlier"), prior_snapshot.clone(), + developer_message("stale permissions diff"), + environment_context_message("/stale"), current_turn_user.clone(), current_turn_tool_output.clone(), same_turn_snapshot.clone(), @@ -283,6 +313,7 @@ fn build_server_side_compaction_replacement_history_keeps_current_turn_inputs() let replacement_history = build_server_side_compaction_replacement_history( compaction_item.clone(), + initial_context.clone(), &history_before_turn, ¤t_history, ); @@ -290,9 +321,11 @@ fn build_server_side_compaction_replacement_history_keeps_current_turn_inputs() assert_eq!( replacement_history, vec![ - compaction_item, + initial_context[0].clone(), + initial_context[1].clone(), current_turn_user, current_turn_tool_output, + compaction_item, prior_snapshot, same_turn_snapshot, ] @@ -304,6 +337,10 @@ fn build_server_side_compaction_replacement_history_replaces_prior_same_turn_sum let prior_snapshot = ghost_snapshot("ghost-before"); let same_turn_snapshot = ghost_snapshot("ghost-during"); let history_before_turn = vec![user_message("earlier"), prior_snapshot.clone()]; + let initial_context = vec![ + developer_message("fresh permissions"), + environment_context_message("/fresh"), + ]; let current_turn_user = user_message("current turn"); let current_turn_tool_output = ResponseItem::FunctionCallOutput { call_id: "call-1".to_string(), @@ -316,15 +353,18 @@ fn build_server_side_compaction_replacement_history_replaces_prior_same_turn_sum encrypted_content: "INLINE_SUMMARY_2".to_string(), }; let current_history = vec![ - prior_compaction, + initial_context[0].clone(), + initial_context[1].clone(), current_turn_user.clone(), current_turn_tool_output.clone(), + prior_compaction, prior_snapshot.clone(), same_turn_snapshot.clone(), ]; let replacement_history = build_server_side_compaction_replacement_history( new_compaction.clone(), + initial_context.clone(), &history_before_turn, ¤t_history, ); @@ -332,9 +372,11 @@ fn build_server_side_compaction_replacement_history_replaces_prior_same_turn_sum assert_eq!( replacement_history, vec![ - new_compaction, + initial_context[0].clone(), + initial_context[1].clone(), current_turn_user, current_turn_tool_output, + new_compaction, prior_snapshot, same_turn_snapshot, ] @@ -345,6 +387,10 @@ fn build_server_side_compaction_replacement_history_replaces_prior_same_turn_sum fn build_server_side_compaction_replacement_history_replaces_prior_summary_with_empty_history() { let same_turn_snapshot = ghost_snapshot("ghost-during"); let history_before_turn = Vec::new(); + let initial_context = vec![ + developer_message("fresh permissions"), + environment_context_message("/fresh"), + ]; let current_turn_user = user_message("current turn"); let current_turn_tool_output = ResponseItem::FunctionCallOutput { call_id: "call-1".to_string(), @@ -357,6 +403,8 @@ fn build_server_side_compaction_replacement_history_replaces_prior_summary_with_ encrypted_content: "INLINE_SUMMARY_2".to_string(), }; let current_history = vec![ + initial_context[0].clone(), + initial_context[1].clone(), prior_compaction, current_turn_user.clone(), current_turn_tool_output.clone(), @@ -365,6 +413,7 @@ fn build_server_side_compaction_replacement_history_replaces_prior_summary_with_ let replacement_history = build_server_side_compaction_replacement_history( new_compaction.clone(), + initial_context.clone(), &history_before_turn, ¤t_history, ); @@ -372,9 +421,11 @@ fn build_server_side_compaction_replacement_history_replaces_prior_summary_with_ assert_eq!( replacement_history, vec![ - new_compaction, + initial_context[0].clone(), + initial_context[1].clone(), current_turn_user, current_turn_tool_output, + new_compaction, same_turn_snapshot, ] ); diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rs index 943868f351..63a2ef6b64 100644 --- a/codex-rs/core/tests/suite/compact_remote.rs +++ b/codex-rs/core/tests/suite/compact_remote.rs @@ -516,6 +516,10 @@ async fn auto_server_side_compaction_uses_inline_context_management() -> Result< post_inline_request.body_contains_text(&inline_summary), "expected subsequent request to reuse inline compaction item" ); + assert!( + post_inline_request.body_contains_text(""), + "expected subsequent request to preserve canonical context after inline compaction" + ); assert!( !post_inline_request.body_contains_text(first_turn_text), "expected pre-compaction user history to be dropped after inline compaction" @@ -586,10 +590,15 @@ async fn auto_server_side_compaction_keeps_current_turn_inputs_for_follow_ups() ); let follow_up_request = &requests[2]; + let follow_up_body = follow_up_request.body_json().to_string(); assert!( follow_up_request.body_contains_text(&inline_summary), "expected same-turn follow-up to include the inline compaction item" ); + assert!( + follow_up_request.body_contains_text(""), + "expected same-turn follow-up to preserve canonical context after inline compaction" + ); assert!( follow_up_request.body_contains_text(second_turn_text), "expected same-turn follow-up to retain the current turn user input" @@ -598,6 +607,15 @@ async fn auto_server_side_compaction_keeps_current_turn_inputs_for_follow_ups() !follow_up_request.body_contains_text(first_turn_text), "expected same-turn follow-up to drop pre-compaction history" ); + assert!( + follow_up_body + .find(second_turn_text) + .expect("current turn text in follow-up request") + < follow_up_body + .find("INLINE_SERVER_SUMMARY") + .expect("inline compaction marker in follow-up request"), + "expected current-turn items to remain ahead of the inline compaction item" + ); assert!( follow_up_request .function_call_output_text("call-inline-mid-turn")