From acd62cc61051a3b95da6d6a902b0d04c32bb8799 Mon Sep 17 00:00:00 2001 From: Ahmed Ibrahim Date: Fri, 24 Oct 2025 13:15:00 -0700 Subject: [PATCH] centralized_processing --- codex-rs/core/src/context_manager/manager.rs | 968 ++++++++++++++++++ codex-rs/core/src/context_manager/mod.rs | 3 + .../core/src/context_manager/truncation.rs | 110 ++ 3 files changed, 1081 insertions(+) create mode 100644 codex-rs/core/src/context_manager/manager.rs create mode 100644 codex-rs/core/src/context_manager/mod.rs create mode 100644 codex-rs/core/src/context_manager/truncation.rs diff --git a/codex-rs/core/src/context_manager/manager.rs b/codex-rs/core/src/context_manager/manager.rs new file mode 100644 index 0000000000..4df513fbc9 --- /dev/null +++ b/codex-rs/core/src/context_manager/manager.rs @@ -0,0 +1,968 @@ +use crate::context_manager::truncation::truncate_context_output; +use codex_protocol::models::FunctionCallOutputPayload; +use codex_protocol::models::ResponseItem; +use codex_protocol::protocol::TokenUsage; +use codex_protocol::protocol::TokenUsageInfo; +use tracing::error; + +/// Transcript of conversation history +#[derive(Debug, Clone, Default)] +pub(crate) struct ContextManager { + /// The oldest items are at the beginning of the vector. + items: Vec, + token_info: Option, +} + +impl ContextManager { + pub(crate) fn new() -> Self { + Self { + items: Vec::new(), + token_info: TokenUsageInfo::new_or_append(&None, &None, None), + } + } + + pub(crate) fn token_info(&self) -> Option { + self.token_info.clone() + } + + pub(crate) fn set_token_usage_full(&mut self, context_window: i64) { + match &mut self.token_info { + Some(info) => info.fill_to_context_window(context_window), + None => { + self.token_info = Some(TokenUsageInfo::full_context_window(context_window)); + } + } + } + + /// `items` is ordered from oldest to newest. + pub(crate) fn record_items(&mut self, items: I) + where + I: IntoIterator, + I::Item: std::ops::Deref, + { + for item in items { + if !is_api_message(&item) { + continue; + } + + let processed = Self::process_item(&item); + self.items.push(processed); + } + } + + pub(crate) fn get_history(&mut self) -> Vec { + self.normalize_history(); + self.contents() + } + + pub(crate) fn remove_first_item(&mut self) { + if !self.items.is_empty() { + // Remove the oldest item (front of the list). Items are ordered from + // oldest → newest, so index 0 is the first entry recorded. + let removed = self.items.remove(0); + // If the removed item participates in a call/output pair, also remove + // its corresponding counterpart to keep the invariants intact without + // running a full normalization pass. + self.remove_corresponding_for(&removed); + } + } + + /// This function enforces a couple of invariants on the in-memory history: + /// 1. every call (function/custom) has a corresponding output entry + /// 2. every output has a corresponding call entry + fn normalize_history(&mut self) { + // all function/tool calls must have a corresponding output + self.ensure_call_outputs_present(); + + // all outputs must have a corresponding function/tool call + self.remove_orphan_outputs(); + } + + fn process_item(item: &ResponseItem) -> ResponseItem { + match item { + ResponseItem::FunctionCallOutput { call_id, output } => { + let truncated_content = truncate_context_output(output.content.as_str()); + ResponseItem::FunctionCallOutput { + call_id: call_id.clone(), + output: FunctionCallOutputPayload { + content: truncated_content, + success: output.success, + }, + } + } + ResponseItem::CustomToolCallOutput { call_id, output } => { + let truncated = truncate_context_output(output); + ResponseItem::CustomToolCallOutput { + call_id: call_id.clone(), + output: truncated, + } + } + _ => item.clone(), + } + } + + /// Returns a clone of the contents in the transcript. + fn contents(&self) -> Vec { + self.items.clone() + } + + fn ensure_call_outputs_present(&mut self) { + // Collect synthetic outputs to insert immediately after their calls. + // Store the insertion position (index of call) alongside the item so + // we can insert in reverse order and avoid index shifting. + let mut missing_outputs_to_insert: Vec<(usize, ResponseItem)> = Vec::new(); + + for (idx, item) in self.items.iter().enumerate() { + match item { + ResponseItem::FunctionCall { call_id, .. } => { + let has_output = self.items.iter().any(|i| match i { + ResponseItem::FunctionCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + + if !has_output { + error_or_panic(format!( + "Function call output is missing for call id: {call_id}" + )); + missing_outputs_to_insert.push(( + idx, + ResponseItem::FunctionCallOutput { + call_id: call_id.clone(), + output: FunctionCallOutputPayload { + content: truncate_context_output("aborted"), + success: None, + }, + }, + )); + } + } + ResponseItem::CustomToolCall { call_id, .. } => { + let has_output = self.items.iter().any(|i| match i { + ResponseItem::CustomToolCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + + if !has_output { + error_or_panic(format!( + "Custom tool call output is missing for call id: {call_id}" + )); + missing_outputs_to_insert.push(( + idx, + ResponseItem::CustomToolCallOutput { + call_id: call_id.clone(), + output: truncate_context_output("aborted"), + }, + )); + } + } + // LocalShellCall is represented in upstream streams by a FunctionCallOutput + ResponseItem::LocalShellCall { call_id, .. } => { + if let Some(call_id) = call_id.as_ref() { + let has_output = self.items.iter().any(|i| match i { + ResponseItem::FunctionCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + + if !has_output { + error_or_panic(format!( + "Local shell call output is missing for call id: {call_id}" + )); + missing_outputs_to_insert.push(( + idx, + ResponseItem::FunctionCallOutput { + call_id: call_id.clone(), + output: FunctionCallOutputPayload { + content: truncate_context_output("aborted"), + success: None, + }, + }, + )); + } + } + } + ResponseItem::Reasoning { .. } + | ResponseItem::WebSearchCall { .. } + | ResponseItem::FunctionCallOutput { .. } + | ResponseItem::CustomToolCallOutput { .. } + | ResponseItem::Other + | ResponseItem::Message { .. } => { + // nothing to do for these variants + } + } + } + + if !missing_outputs_to_insert.is_empty() { + // Insert from the end to avoid shifting subsequent indices. + missing_outputs_to_insert.sort_by_key(|(i, _)| *i); + for (idx, item) in missing_outputs_to_insert.into_iter().rev() { + let insert_pos = idx + 1; // place immediately after the call + if insert_pos <= self.items.len() { + self.items.insert(insert_pos, item); + } else { + self.items.push(item); + } + } + } + } + + fn remove_orphan_outputs(&mut self) { + // Work on a snapshot to avoid borrowing `self.items` while mutating it. + let snapshot = self.items.clone(); + let mut orphan_output_call_ids: std::collections::HashSet = + std::collections::HashSet::new(); + + for item in &snapshot { + match item { + ResponseItem::FunctionCallOutput { call_id, .. } => { + let has_call = snapshot.iter().any(|i| match i { + ResponseItem::FunctionCall { + call_id: existing, .. + } => existing == call_id, + ResponseItem::LocalShellCall { + call_id: Some(existing), + .. + } => existing == call_id, + _ => false, + }); + + if !has_call { + error_or_panic(format!("Function call is missing for call id: {call_id}")); + orphan_output_call_ids.insert(call_id.clone()); + } + } + ResponseItem::CustomToolCallOutput { call_id, .. } => { + let has_call = snapshot.iter().any(|i| match i { + ResponseItem::CustomToolCall { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + + if !has_call { + error_or_panic(format!( + "Custom tool call is missing for call id: {call_id}" + )); + orphan_output_call_ids.insert(call_id.clone()); + } + } + ResponseItem::FunctionCall { .. } + | ResponseItem::CustomToolCall { .. } + | ResponseItem::LocalShellCall { .. } + | ResponseItem::Reasoning { .. } + | ResponseItem::WebSearchCall { .. } + | ResponseItem::Other + | ResponseItem::Message { .. } => { + // nothing to do for these variants + } + } + } + + if !orphan_output_call_ids.is_empty() { + let ids = orphan_output_call_ids; + self.items.retain(|i| match i { + ResponseItem::FunctionCallOutput { call_id, .. } + | ResponseItem::CustomToolCallOutput { call_id, .. } => !ids.contains(call_id), + _ => true, + }); + } + } + + pub(crate) fn replace(&mut self, items: Vec) { + self.items = items + .into_iter() + .map(|item| Self::process_item(&item)) + .collect(); + } + + /// Removes the corresponding paired item for the provided `item`, if any. + /// + /// Pairs: + /// - FunctionCall <-> FunctionCallOutput + /// - CustomToolCall <-> CustomToolCallOutput + /// - LocalShellCall(call_id: Some) <-> FunctionCallOutput + fn remove_corresponding_for(&mut self, item: &ResponseItem) { + match item { + ResponseItem::FunctionCall { call_id, .. } => { + self.remove_first_matching(|i| match i { + ResponseItem::FunctionCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + } + ResponseItem::CustomToolCall { call_id, .. } => { + self.remove_first_matching(|i| match i { + ResponseItem::CustomToolCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + } + ResponseItem::LocalShellCall { + call_id: Some(call_id), + .. + } => { + self.remove_first_matching(|i| match i { + ResponseItem::FunctionCallOutput { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + } + ResponseItem::FunctionCallOutput { call_id, .. } => { + self.remove_first_matching(|i| match i { + ResponseItem::FunctionCall { + call_id: existing, .. + } => existing == call_id, + ResponseItem::LocalShellCall { + call_id: Some(existing), + .. + } => existing == call_id, + _ => false, + }); + } + ResponseItem::CustomToolCallOutput { call_id, .. } => { + self.remove_first_matching(|i| match i { + ResponseItem::CustomToolCall { + call_id: existing, .. + } => existing == call_id, + _ => false, + }); + } + _ => {} + } + } + + /// Remove the first item matching the predicate. + fn remove_first_matching(&mut self, predicate: F) + where + F: FnMut(&ResponseItem) -> bool, + { + if let Some(pos) = self.items.iter().position(predicate) { + self.items.remove(pos); + } + } + + pub(crate) fn update_token_info( + &mut self, + usage: &TokenUsage, + model_context_window: Option, + ) { + self.token_info = TokenUsageInfo::new_or_append( + &self.token_info, + &Some(usage.clone()), + model_context_window, + ); + } +} + +#[inline] +fn error_or_panic(message: String) { + if cfg!(debug_assertions) || env!("CARGO_PKG_VERSION").contains("alpha") { + panic!("{message}"); + } else { + error!("{message}"); + } +} + +/// Anything that is not a system message or "reasoning" message is considered +/// an API message. +fn is_api_message(message: &ResponseItem) -> bool { + match message { + ResponseItem::Message { role, .. } => role.as_str() != "system", + ResponseItem::FunctionCallOutput { .. } + | ResponseItem::FunctionCall { .. } + | ResponseItem::CustomToolCall { .. } + | ResponseItem::CustomToolCallOutput { .. } + | ResponseItem::LocalShellCall { .. } + | ResponseItem::Reasoning { .. } + | ResponseItem::WebSearchCall { .. } => true, + ResponseItem::Other => false, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::context_manager::truncation::CONTEXT_OUTPUT_MAX_BYTES; + use crate::context_manager::truncation::CONTEXT_OUTPUT_TRUNCATION_NOTICE; + use codex_protocol::models::ContentItem; + use codex_protocol::models::FunctionCallOutputPayload; + use codex_protocol::models::LocalShellAction; + use codex_protocol::models::LocalShellExecAction; + use codex_protocol::models::LocalShellStatus; + use pretty_assertions::assert_eq; + + fn assistant_msg(text: &str) -> ResponseItem { + ResponseItem::Message { + id: None, + role: "assistant".to_string(), + content: vec![ContentItem::OutputText { + text: text.to_string(), + }], + } + } + + fn create_history_with_items(items: Vec) -> ContextManager { + let mut h = ContextManager::new(); + h.record_items(items.iter()); + h + } + + fn user_msg(text: &str) -> ResponseItem { + ResponseItem::Message { + id: None, + role: "user".to_string(), + content: vec![ContentItem::OutputText { + text: text.to_string(), + }], + } + } + + #[test] + fn filters_non_api_messages() { + let mut h = ContextManager::default(); + // System message is not an API message; Other is ignored. + let system = ResponseItem::Message { + id: None, + role: "system".to_string(), + content: vec![ContentItem::OutputText { + text: "ignored".to_string(), + }], + }; + h.record_items([&system, &ResponseItem::Other]); + + // User and assistant should be retained. + let u = user_msg("hi"); + let a = assistant_msg("hello"); + h.record_items([&u, &a]); + + let items = h.contents(); + assert_eq!( + items, + vec![ + ResponseItem::Message { + id: None, + role: "user".to_string(), + content: vec![ContentItem::OutputText { + text: "hi".to_string() + }] + }, + ResponseItem::Message { + id: None, + role: "assistant".to_string(), + content: vec![ContentItem::OutputText { + text: "hello".to_string() + }] + } + ] + ); + } + + #[test] + fn record_items_truncates_function_call_output() { + let mut h = ContextManager::new(); + let long_content = "a".repeat(CONTEXT_OUTPUT_MAX_BYTES + 32); + let item = ResponseItem::FunctionCallOutput { + call_id: "call-long".to_string(), + output: FunctionCallOutputPayload { + content: long_content.clone(), + success: Some(true), + }, + }; + + h.record_items([&item]); + + let stored = h.contents(); + let ResponseItem::FunctionCallOutput { output, .. } = &stored[0] else { + panic!("expected FunctionCallOutput variant"); + }; + assert!( + output.content.ends_with(CONTEXT_OUTPUT_TRUNCATION_NOTICE), + "truncated content should end with notice" + ); + assert!( + output.content.len() < long_content.len(), + "content should shrink after truncation" + ); + } + + #[test] + fn record_items_truncates_custom_tool_output() { + let mut h = ContextManager::new(); + let long_content = "b".repeat(CONTEXT_OUTPUT_MAX_BYTES + 64); + let item = ResponseItem::CustomToolCallOutput { + call_id: "custom-long".to_string(), + output: long_content.clone(), + }; + + h.record_items([&item]); + + let stored = h.contents(); + let ResponseItem::CustomToolCallOutput { output, .. } = &stored[0] else { + panic!("expected CustomToolCallOutput variant"); + }; + assert!( + output.ends_with(CONTEXT_OUTPUT_TRUNCATION_NOTICE), + "truncated output should end with notice" + ); + assert!( + output.len() < long_content.len(), + "output should shrink after truncation" + ); + } + + #[test] + fn remove_first_item_removes_matching_output_for_function_call() { + let items = vec![ + ResponseItem::FunctionCall { + id: None, + name: "do_it".to_string(), + arguments: "{}".to_string(), + call_id: "call-1".to_string(), + }, + ResponseItem::FunctionCallOutput { + call_id: "call-1".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }, + ]; + let mut h = create_history_with_items(items); + h.remove_first_item(); + assert_eq!(h.contents(), vec![]); + } + + #[test] + fn remove_first_item_removes_matching_call_for_output() { + let items = vec![ + ResponseItem::FunctionCallOutput { + call_id: "call-2".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }, + ResponseItem::FunctionCall { + id: None, + name: "do_it".to_string(), + arguments: "{}".to_string(), + call_id: "call-2".to_string(), + }, + ]; + let mut h = create_history_with_items(items); + h.remove_first_item(); + assert_eq!(h.contents(), vec![]); + } + + #[test] + fn remove_first_item_handles_local_shell_pair() { + let items = vec![ + ResponseItem::LocalShellCall { + id: None, + call_id: Some("call-3".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string(), "hi".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }, + ResponseItem::FunctionCallOutput { + call_id: "call-3".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }, + ]; + let mut h = create_history_with_items(items); + h.remove_first_item(); + assert_eq!(h.contents(), vec![]); + } + + #[test] + fn remove_first_item_handles_custom_tool_pair() { + let items = vec![ + ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "tool-1".to_string(), + name: "my_tool".to_string(), + input: "{}".to_string(), + }, + ResponseItem::CustomToolCallOutput { + call_id: "tool-1".to_string(), + output: "ok".to_string(), + }, + ]; + let mut h = create_history_with_items(items); + h.remove_first_item(); + assert_eq!(h.contents(), vec![]); + } + + //TODO(aibrahim): run CI in release mode. + #[cfg(not(debug_assertions))] + #[test] + fn normalize_adds_missing_output_for_function_call() { + let items = vec![ResponseItem::FunctionCall { + id: None, + name: "do_it".to_string(), + arguments: "{}".to_string(), + call_id: "call-x".to_string(), + }]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!( + h.contents(), + vec![ + ResponseItem::FunctionCall { + id: None, + name: "do_it".to_string(), + arguments: "{}".to_string(), + call_id: "call-x".to_string(), + }, + ResponseItem::FunctionCallOutput { + call_id: "call-x".to_string(), + output: FunctionCallOutputPayload { + content: "aborted".to_string(), + success: None, + }, + }, + ] + ); + } + + #[cfg(not(debug_assertions))] + #[test] + fn normalize_adds_missing_output_for_custom_tool_call() { + let items = vec![ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "tool-x".to_string(), + name: "custom".to_string(), + input: "{}".to_string(), + }]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!( + h.contents(), + vec![ + ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "tool-x".to_string(), + name: "custom".to_string(), + input: "{}".to_string(), + }, + ResponseItem::CustomToolCallOutput { + call_id: "tool-x".to_string(), + output: "aborted".to_string(), + }, + ] + ); + } + + #[cfg(not(debug_assertions))] + #[test] + fn normalize_adds_missing_output_for_local_shell_call_with_id() { + let items = vec![ResponseItem::LocalShellCall { + id: None, + call_id: Some("shell-1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string(), "hi".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!( + h.contents(), + vec![ + ResponseItem::LocalShellCall { + id: None, + call_id: Some("shell-1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string(), "hi".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }, + ResponseItem::FunctionCallOutput { + call_id: "shell-1".to_string(), + output: FunctionCallOutputPayload { + content: "aborted".to_string(), + success: None, + }, + }, + ] + ); + } + + #[cfg(not(debug_assertions))] + #[test] + fn normalize_removes_orphan_function_call_output() { + let items = vec![ResponseItem::FunctionCallOutput { + call_id: "orphan-1".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!(h.contents(), vec![]); + } + + #[cfg(not(debug_assertions))] + #[test] + fn normalize_removes_orphan_custom_tool_call_output() { + let items = vec![ResponseItem::CustomToolCallOutput { + call_id: "orphan-2".to_string(), + output: "ok".to_string(), + }]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!(h.contents(), vec![]); + } + + #[cfg(not(debug_assertions))] + #[test] + fn normalize_mixed_inserts_and_removals() { + let items = vec![ + // Will get an inserted output + ResponseItem::FunctionCall { + id: None, + name: "f1".to_string(), + arguments: "{}".to_string(), + call_id: "c1".to_string(), + }, + // Orphan output that should be removed + ResponseItem::FunctionCallOutput { + call_id: "c2".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }, + // Will get an inserted custom tool output + ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "t1".to_string(), + name: "tool".to_string(), + input: "{}".to_string(), + }, + // Local shell call also gets an inserted function call output + ResponseItem::LocalShellCall { + id: None, + call_id: Some("s1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }, + ]; + let mut h = create_history_with_items(items); + + h.normalize_history(); + + assert_eq!( + h.contents(), + vec![ + ResponseItem::FunctionCall { + id: None, + name: "f1".to_string(), + arguments: "{}".to_string(), + call_id: "c1".to_string(), + }, + ResponseItem::FunctionCallOutput { + call_id: "c1".to_string(), + output: FunctionCallOutputPayload { + content: "aborted".to_string(), + success: None, + }, + }, + ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "t1".to_string(), + name: "tool".to_string(), + input: "{}".to_string(), + }, + ResponseItem::CustomToolCallOutput { + call_id: "t1".to_string(), + output: "aborted".to_string(), + }, + ResponseItem::LocalShellCall { + id: None, + call_id: Some("s1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }, + ResponseItem::FunctionCallOutput { + call_id: "s1".to_string(), + output: FunctionCallOutputPayload { + content: "aborted".to_string(), + success: None, + }, + }, + ] + ); + } + + // In debug builds we panic on normalization errors instead of silently fixing them. + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_adds_missing_output_for_function_call_panics_in_debug() { + let items = vec![ResponseItem::FunctionCall { + id: None, + name: "do_it".to_string(), + arguments: "{}".to_string(), + call_id: "call-x".to_string(), + }]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } + + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_adds_missing_output_for_custom_tool_call_panics_in_debug() { + let items = vec![ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "tool-x".to_string(), + name: "custom".to_string(), + input: "{}".to_string(), + }]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } + + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_adds_missing_output_for_local_shell_call_with_id_panics_in_debug() { + let items = vec![ResponseItem::LocalShellCall { + id: None, + call_id: Some("shell-1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string(), "hi".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } + + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_removes_orphan_function_call_output_panics_in_debug() { + let items = vec![ResponseItem::FunctionCallOutput { + call_id: "orphan-1".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } + + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_removes_orphan_custom_tool_call_output_panics_in_debug() { + let items = vec![ResponseItem::CustomToolCallOutput { + call_id: "orphan-2".to_string(), + output: "ok".to_string(), + }]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } + + #[cfg(debug_assertions)] + #[test] + #[should_panic] + fn normalize_mixed_inserts_and_removals_panics_in_debug() { + let items = vec![ + ResponseItem::FunctionCall { + id: None, + name: "f1".to_string(), + arguments: "{}".to_string(), + call_id: "c1".to_string(), + }, + ResponseItem::FunctionCallOutput { + call_id: "c2".to_string(), + output: FunctionCallOutputPayload { + content: "ok".to_string(), + success: None, + }, + }, + ResponseItem::CustomToolCall { + id: None, + status: None, + call_id: "t1".to_string(), + name: "tool".to_string(), + input: "{}".to_string(), + }, + ResponseItem::LocalShellCall { + id: None, + call_id: Some("s1".to_string()), + status: LocalShellStatus::Completed, + action: LocalShellAction::Exec(LocalShellExecAction { + command: vec!["echo".to_string()], + timeout_ms: None, + working_directory: None, + env: None, + user: None, + }), + }, + ]; + let mut h = create_history_with_items(items); + h.normalize_history(); + } +} diff --git a/codex-rs/core/src/context_manager/mod.rs b/codex-rs/core/src/context_manager/mod.rs new file mode 100644 index 0000000000..23d68e112d --- /dev/null +++ b/codex-rs/core/src/context_manager/mod.rs @@ -0,0 +1,3 @@ +mod manager; +pub(crate) use manager::ContextManager; +pub mod truncation; diff --git a/codex-rs/core/src/context_manager/truncation.rs b/codex-rs/core/src/context_manager/truncation.rs new file mode 100644 index 0000000000..18847810b1 --- /dev/null +++ b/codex-rs/core/src/context_manager/truncation.rs @@ -0,0 +1,110 @@ +use codex_utils_string::take_bytes_at_char_boundary; + +#[derive(Clone, Copy)] +pub(crate) struct TruncationConfig { + pub max_bytes: usize, + pub max_lines: usize, + pub truncation_notice: &'static str, +} + +pub(crate) const CONTEXT_OUTPUT_MAX_BYTES: usize = 8 * 1024; // 8 KiB +pub(crate) const CONTEXT_OUTPUT_MAX_LINES: usize = 256; +pub(crate) const CONTEXT_OUTPUT_TRUNCATION_NOTICE: &str = "[... output truncated ...]"; + +pub(crate) const CONTEXT_OUTPUT_TRUNCATION: TruncationConfig = TruncationConfig { + max_bytes: CONTEXT_OUTPUT_MAX_BYTES, + max_lines: CONTEXT_OUTPUT_MAX_LINES, + truncation_notice: CONTEXT_OUTPUT_TRUNCATION_NOTICE, +}; + +pub(crate) fn truncate_with_config(content: &str, config: TruncationConfig) -> String { + let TruncationConfig { + max_bytes, + max_lines, + truncation_notice, + } = config; + + let truncated_slice = take_bytes_at_char_boundary(content, max_bytes); + let truncated_by_bytes = truncated_slice.len() < content.len(); + + let mut preview = String::new(); + let mut lines_iter = truncated_slice.lines(); + for idx in 0..max_lines { + match lines_iter.next() { + Some(line) => { + if idx > 0 { + preview.push('\n'); + } + preview.push_str(line); + } + None => break, + } + } + let truncated_by_lines = lines_iter.next().is_some(); + + if !truncated_by_bytes && !truncated_by_lines { + return content.to_string(); + } + + if preview.len() < truncated_slice.len() + && truncated_slice + .as_bytes() + .get(preview.len()) + .is_some_and(|byte| *byte == b'\n') + { + preview.push('\n'); + } + + if !preview.is_empty() && !preview.ends_with('\n') { + preview.push('\n'); + } + + preview.push_str(truncation_notice); + preview +} + +pub(crate) fn truncate_context_output(content: &str) -> String { + truncate_with_config(content, CONTEXT_OUTPUT_TRUNCATION) +} + +#[cfg(test)] +mod tests { + use super::*; + use pretty_assertions::assert_eq; + + #[test] + fn truncate_with_config_returns_original_within_limits() { + let content = "short output"; + let config = TruncationConfig { + max_bytes: 64, + max_lines: 5, + truncation_notice: "[notice]", + }; + assert_eq!(truncate_with_config(content, config), content); + } + + #[test] + fn truncate_with_config_truncates_by_bytes() { + let config = TruncationConfig { + max_bytes: 16, + max_lines: 10, + truncation_notice: "[notice]", + }; + let content = "abcdefghijklmnopqrstuvwxyz"; + let truncated = truncate_with_config(content, config); + assert!(truncated.contains("[notice]")); + } + + #[test] + fn truncate_with_config_truncates_by_lines() { + let config = TruncationConfig { + max_bytes: 1024, + max_lines: 2, + truncation_notice: "[notice]", + }; + let content = "l1\nl2\nl3\nl4"; + let truncated = truncate_with_config(content, config); + assert!(truncated.lines().count() <= 3); + assert!(truncated.contains("[notice]")); + } +}