Lightweight coding agent that runs in your terminal
Rust
Preserve live tool-call metadata across request windows (#49401)
ningyi-oai87d3e068478c
diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rsindex 07d57f5536..1562fb1958 100644--- a/codex-rs/core/src/client_tests.rs+++ b/codex-rs/core/src/client_tests.rs@@ -523,10 +523,14 @@ async fn responses_request_includes_internal_metadata_for_provider_grant_or_firsrecorder.attach_direct_call_to_output(&mut item, Some((recorded, permit)));outputs.push(item);}- let original_outputs = outputs.clone();+ let persisted_outputs = outputs.clone();recorder.attach_to_prompt(&mut outputs, &mut Default::default());- assert_eq!(outputs, original_outputs);- let recorded = serde_json::to_value(&outputs)?;+ let restored = serde_json::to_value(&outputs)?;+ assert_eq!(+ restored[1]["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],+ resource_metadata,+ );+ let recorded = serde_json::to_value(&persisted_outputs)?;assert_eq!(recorded[0]["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],resource_metadata,@@ -537,11 +541,12 @@ async fn responses_request_includes_internal_metadata_for_provider_grant_or_firs.as_str().is_some_and(|value| value.starts_with("omitted_due_to_size_limit (overage_bytes=")));- let omitted_output = outputs.pop().expect("second direct output");+ let omitted_output = persisted_outputs[1].clone();let mut without_omitted_metadata = ResponseItem::from(ResponseInputItem::FunctionCallOutput {call_id: "second".to_string(),output: FunctionCallOutputPayload::from_text("result for second".to_string()),});+ without_omitted_metadata.set_id(omitted_output.id().cloned());without_omitted_metadata.append_executed_tool_calls(vec![ExecutedToolCall::new("mcp__apps__read".to_string(),json!({"query": "second"}),@@ -801,7 +806,6 @@ fn responses_request_preserves_result_metadata_above_previous_aggregate_budget()let metadata_bytes =serde_json::to_vec(&body)?.len() - serde_json::to_vec(&without_metadata)?.len();assert!(metadata_bytes > 128 * 1024);- assert!(metadata_bytes <= 2 * 1024 * 1024);assert_eq!(serde_json::to_value(&history)?, original_history);Ok(())}diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 056f9f0ce9..b876976846 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -3393,7 +3393,7 @@ impl Session {items}- fn assign_missing_response_item_id(item: &mut ResponseItem) {+ pub(crate) fn assign_missing_response_item_id(item: &mut ResponseItem) {if item.id().is_some_and(|id| !id.is_empty()) {return;}diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rsindex ee05b483bd..636d3cbd92 100644--- a/codex-rs/core/src/tools/executed_tool_calls.rs+++ b/codex-rs/core/src/tools/executed_tool_calls.rs@@ -20,19 +20,20 @@ use codex_code_mode::CellId;use codex_features::Feature;use codex_features::Features;use codex_history::InitialHistory;+use codex_protocol::ResponseItemId;use codex_protocol::mcp::McpAttribution;use codex_protocol::mcp::McpAttributionSource;use codex_protocol::models::ExecutedToolCall;use codex_protocol::models::ExecutedToolCallArguments;use codex_protocol::models::ResponseItem;use codex_protocol::models::ToolResultMetadata;-use codex_protocol::models::bound_executed_tool_calls_for_prompt;-use codex_protocol::models::bound_executed_tool_calls_for_prompt_prioritizing_recent;use codex_protocol::models::executed_tool_call_metadata_bytes;+use codex_protocol::models::normalize_executed_tool_call_arguments;use codex_protocol::openai_models::ToolMode;use indexmap::IndexMap;use serde_json::Value as JsonValue;+use crate::session::session::Session;use crate::session::step_context::StepContext;use crate::tools::context::ToolCallSource;use crate::tools::context::ToolOutput;@@ -97,6 +98,8 @@ impl Drop for DirectCallPermit {struct ExecutedToolCallRecorderState {// Disabling drops this lifetime, permanently invalidating prepared Direct records.recording: Arc<()>,+ // Full live Direct observations; persisted outputs keep their bounded projection.+ direct_calls: HashMap<ResponseItemId, ExecutedToolCall>,cells: HashMap<CellId, RecordedCell>,output_cells: HashMap<String, CellId>,retained_calls: HashMap<(std::mem::Discriminant<ResponseItem>, String), RetainedToolCalls>,@@ -399,13 +402,19 @@ impl ExecutedToolCalls {let Some((call, permit)) = prepared else {return;};- let state = self.lock_state();- let Some(state) = state.as_ref() else {+ let mut state = self.lock_state();+ let Some(state) = state.as_mut() else {return;};if !permit.recording.ptr_eq(&Arc::downgrade(&state.recording)) {return;}+ // Assign the output's ordinary history ID here so reused model call IDs+ // cannot associate this observation with a different output.+ Session::assign_missing_response_item_id(item);+ if let Some(id) = item.id() {+ state.direct_calls.insert(id.clone(), call.clone());+ }let complete = matches!(call.arguments(), ExecutedToolCallArguments::Raw(_));item.append_executed_tool_calls(vec![call]);if complete {diff --git a/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs b/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rsindex 762eccee89..1ae9eefb16 100644--- a/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs+++ b/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs@@ -1,59 +1,74 @@-//! Attaches host observations to request metadata and applies its byte budget.-//! Final request budgeting runs after the recorder lock is released; it never changes tool execution.+//! Attaches host observations to request metadata without changing tool execution.use super::*;#[derive(Clone, Copy, PartialEq, Eq)]-enum MetadataBudgetScope {- AllCalls,- CodeModeOnly,+enum RequestKind {+ Sampling,+ Compaction,}impl ExecutedToolCalls {- /// Attaches Code Mode observations while preserving Direct records captured in history.pub(crate) fn attach_to_compaction_prompt(&self, items: &mut [ResponseItem]) {- let mut state = self.lock_state();- let Some(state) = state.as_mut() else {- clear_direct_call_metadata(items);- return;- };- Self::attach_pending_to_prompt_with_state(- state,- items,- &mut HashMap::new(),- MetadataBudgetScope::CodeModeOnly,- );+ self.attach_to_request(items, &mut HashMap::new(), RequestKind::Compaction);}- /// Attaches trusted completeness; request budgeting only revokes damaged inventories.pub(crate) fn attach_to_prompt(&self,items: &mut [ResponseItem],retry_cache: &mut ExecutedToolCallCache,) {- let attached = {+ self.attach_to_request(items, retry_cache, RequestKind::Sampling);+ }++ fn attach_to_request(+ &self,+ items: &mut [ResponseItem],+ retry_cache: &mut ExecutedToolCallCache,+ request_kind: RequestKind,+ ) {+ let recording = {let mut state = self.lock_state();- state.as_mut().map(|state| {- Self::attach_pending_to_prompt_with_state(- state,- items,- retry_cache,- MetadataBudgetScope::AllCalls,- )- })- };- let Some(attached) = attached else {- // Direct records now live in history; disabling capture also stops replaying them.- clear_direct_call_metadata(items);- return;+ let Some(state) = state.as_mut() else {+ // Disabling capture also stops replaying Direct records from history.+ clear_direct_call_metadata(items);+ return;+ };+ for item in items.iter_mut() {+ if let Some(call) = item.id().and_then(|id| state.direct_calls.get(id)) {+ item.clear_executed_tool_calls();+ item.append_executed_tool_calls(vec![call.clone()]);+ if matches!(call.arguments(), ExecutedToolCallArguments::Raw(_)) {+ item.mark_tool_calls_complete();+ }+ }+ }+ // A shortened compaction attempt is not an installed history window.+ // Only ordinary sampling can discard observations absent from the window.+ if request_kind == RequestKind::Sampling && !state.direct_calls.is_empty() {+ let output_ids = items+ .iter()+ .filter_map(ResponseItem::id)+ .collect::<HashSet<_>>();+ state.direct_calls.retain(|id, _| output_ids.contains(id));+ }+ Self::attach_pending_to_prompt_with_state(state, items, retry_cache, request_kind);+ Arc::downgrade(&state.recording)};- if attached || items.iter().any(has_direct_call_metadata) {- metadata_metrics::bound_prompt_metadata(- items,- bound_executed_tool_calls_for_prompt,- "request",- codex_otel::global().as_ref(),- );++ // Existing history can contain arguments recorded by an older client. Keep the+ // per-call limit, and prevent newly truncated cells from claiming completeness+ // on a later wait. Do the serialization outside the recorder lock.+ let truncated_origins = normalize_executed_tool_call_arguments(items);+ if !truncated_origins.is_empty() {+ let mut state = self.lock_state();+ if let Some(state) = state.as_mut()+ && recording.ptr_eq(&Arc::downgrade(&state.recording))+ {+ for origin in truncated_origins {+ state.invalidate_origin(&origin);+ }+ }}}@@ -61,7 +76,7 @@ impl ExecutedToolCalls {state: &mut ExecutedToolCallRecorderState,items: &mut [ResponseItem],retry_cache: &mut ExecutedToolCallCache,- budget_scope: MetadataBudgetScope,+ request_kind: RequestKind,) -> bool {// Failed wrappers have no callback; only their bounded bitmap observation survives.state.pending_wrapper_origins.clear();@@ -317,7 +332,7 @@ impl ExecutedToolCalls {}// Compaction may retry with a shortened history without installing that history.// Keep absent observations until a normal sampling request confirms the live window.- if budget_scope == MetadataBudgetScope::AllCalls && !pending_outputs.is_empty() {+ if request_kind == RequestKind::Sampling && !pending_outputs.is_empty() {state.retained_calls.retain(|key, _| !pending_outputs.contains(key));@@ -378,6 +393,7 @@ impl ExecutedToolCalls {.is_some_and(|cell_id| invalid_cells.contains(cell_id)){retained.complete = false;+ retained.call_index_by_id.clear();retained.clear_late_truncated_metadata();}}@@ -400,122 +416,6 @@ impl ExecutedToolCalls {}}- let metadata_bytes = items- .iter()- .filter(|item| {- budget_scope == MetadataBudgetScope::AllCalls || !has_direct_call_metadata(item)- })- .fold(0_usize, |bytes, item| {- bytes.saturating_add(executed_tool_call_metadata_bytes(item))- });- if metadata_bytes > MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT {- match budget_scope {- MetadataBudgetScope::AllCalls => {- metadata_metrics::bound_prompt_metadata(- items,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- "retained",- codex_otel::global().as_ref(),- );- }- MetadataBudgetScope::CodeModeOnly => {- // Validate bindings against the complete history above, but do not make- // captured Direct records compete with Code Mode's bounded recorder.- let (indices, mut bounded): (Vec<_>, Vec<_>) = items- .iter()- .enumerate()- .filter(|(_, item)| {- !has_direct_call_metadata(item)- && item.executed_tool_call_metadata().is_some()- })- .map(|(index, item)| (index, item.clone()))- .unzip();- metadata_metrics::bound_prompt_metadata(- &mut bounded,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- "compaction",- codex_otel::global().as_ref(),- );- for (index, item) in indices.into_iter().zip(bounded) {- items[index] = item;- }- }- }- let retained_before_bounding = std::mem::take(&mut state.retained_calls);- let mut bounded_outputs = HashSet::new();- for item in items.iter_mut() {- if has_direct_call_metadata(item) {- continue;- }- let Some(call_id) = output_call_id(item) else {- continue;- };- let key = (std::mem::discriminant(&*item), call_id.to_string());- // History already carries unmanaged records; retaining them would append them again.- let Some(previous) = retained_before_bounding.get(&key) else {- continue;- };- let metadata = item.executed_tool_call_metadata();- let unique_output = bounded_outputs.insert(key.clone());- if !unique_output && let Some(retained) = state.retained_calls.get_mut(&key) {- retained.call_index_by_id.clear();- retained.clear_late_truncated_metadata();- }- if let Some(runtime_cell_id) = &previous.runtime_cell_id- && metadata- .is_none_or(|metadata| !metadata.has_same_tool_calls(&previous.calls))- && let Some(cell) = state.cells.get_mut(runtime_cell_id)- {- cell.completion = CellCompletion::Incomplete;- }- if let Some(metadata) = metadata- && (metadata- .executed_tool_calls- .as_ref()- .is_some_and(|calls| !calls.is_empty())- || metadata.tool_calls_complete.is_some())- {- // Metadata-only shedding preserves slots; changed calls or duplicate outputs do not.- let same_calls = unique_output && metadata.has_same_tool_calls(&previous.calls);- let call_index_by_id = if same_calls {- previous.call_index_by_id.clone()- } else {- HashMap::new()- };- let retained = state.retained_calls.entry(key).or_default();- retained.runtime_cell_id = previous.runtime_cell_id.clone();- retained.calls = metadata.executed_tool_calls.clone().unwrap_or_default();- if let Some(cell_id) = metadata.cell_id.as_ref() {- retained.cell_id = Some(cell_id.clone());- }- retained.complete |= metadata.tool_calls_complete == Some(true);- retained.call_index_by_id = call_index_by_id;- // Budgeting preserves call order; changed inventories lose their indices.- if same_calls {- retained.truncated_call_index_by_id =- previous.truncated_call_index_by_id.clone();- retained.late_truncated_indices = previous.late_truncated_indices.clone();- } else {- // The budgeter never reorders calls. Remove only the new late- // evidence before losing the indices that identify it.- for index in &previous.late_truncated_indices {- if let Some(call) = retained.calls.get_mut(*index) {- call.set_tool_result_metadata(ToolResultMetadata::default());- }- }- }- retained.result_metadata_updated = previous.result_metadata_updated;- }- }- if budget_scope == MetadataBudgetScope::CodeModeOnly {- state.retained_calls.extend(- retained_before_bounding- .into_iter()- .filter(|(key, _)| pending_outputs.contains(key)),- );- }- }-attached}}diff --git a/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs b/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rsindex c92841f413..efa05e24e6 100644--- a/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs+++ b/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs@@ -20,12 +20,7 @@ impl ExecutedToolCalls {let Some(state) = state.as_mut() else {return false;};- Self::attach_pending_to_prompt_with_state(- state,- items,- retry_cache,- MetadataBudgetScope::AllCalls,- )+ Self::attach_pending_to_prompt_with_state(state, items, retry_cache, RequestKind::Sampling)}}@@ -145,147 +140,133 @@ fn compaction_attaches_pending_and_retained_code_mode_metadata() {}#[test]-fn failed_compaction_preserves_observations_absent_from_trimmed_retries() {- let call_count = 100;- for rebudget in [false, true] {- let recorder = new_recorder(InitialHistory::New);- let mut history = Vec::new();- for origin in ["old", "recent"] {- let cell = CellId::new(origin.to_string());- recorder.start_cell(&cell, origin);- for index in 0..call_count {- record_nested_call(&recorder, &cell, &format!("nested-{index}"));- }- recorder.finish_cell_recording(&cell);- history.extend([exec_input(origin), exec_output(origin)]);- }- let mut full_attempt = history.clone();- recorder.attach_to_compaction_prompt(&mut full_attempt);- assert_eq!(tool_calls_complete(&full_attempt[1]), Some(true));-- if rebudget {- // Late results make the retained retry item exceed the budget independently of- // the older output that the compaction retry has temporarily removed.- let source = ToolCallSource::CodeMode {- cell_id: "recent".to_string(),- runtime_tool_call_id: "runtime".to_string(),- };- for index in 0..call_count {- assert!(recorder.record_tool_result_metadata(- &source,- &format!("nested-{index}"),- &json!({"provider": "x".repeat(24 * 1024)}),- ));- }- }- let mut trimmed_attempt = history[2..].to_vec();- recorder.attach_to_compaction_prompt(&mut trimmed_attempt);- assert_eq!(tool_calls_complete(&trimmed_attempt[1]), Some(true));- if rebudget {- let encoded = serde_json::to_value(&trimmed_attempt[1]).unwrap();- assert!(- encoded["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"]- .as_str()- .is_some_and(|marker| marker.starts_with("omitted_due_to_size_limit (overage_bytes=")),- );- }-- // Exhausted retries leave the session's original history intact.- let mut expected = full_attempt;- expected[2..].clone_from_slice(&trimmed_attempt);- // The restored inventory must fit without causing another round of raw-result shedding.- assert!(- expected- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- <= 2 * 1024 * 1024- );- let mut resumed = history.clone();- recorder.attach_to_prompt(&mut resumed, &mut HashMap::new());- assert_eq!(resumed, expected);- // Once ordinary sampling advances to a smaller window, the old record is pruned.- recorder.attach_to_prompt(&mut history[2..], &mut HashMap::new());- let mut old = vec![exec_input("old"), exec_output("old")];- recorder.attach_to_prompt(&mut old, &mut HashMap::new());- assert_eq!(old, vec![exec_input("old"), exec_output("old")]);- }-}--#[test]-fn compaction_bounds_code_mode_metadata_without_rebudgeting_direct_history() {+fn large_direct_and_code_mode_metadata_survive_sampling_and_compaction() {let recorder = new_recorder(InitialHistory::New);- let mut history = Vec::new();- let arguments = json!({"value": "x".repeat(7 * 1024)});- let argument_bytes = serialized_json_bytes(&arguments).unwrap();- for index in 0..96 {- let origin = format!("exec-{index}");- let cell = CellId::new(format!("cell-{index}"));- recorder.start_cell(&cell, &origin);- let mut call = ExecutedToolCall::new("nested_tool".to_string(), arguments.clone());- call.set_tool_result_metadata(ToolResultMetadata::new(&json!({- "provider": "x".repeat(24 * 1024),- })));- recorder.record_nested_tool_call(- cell.clone(),- format!("nested-{index}"),- call,- argument_bytes,- );- recorder.finish_cell_recording(&cell);- history.extend([exec_input(&origin), exec_output(&origin)]);- }- let direct_start = history.len();- for index in 0..24 {- let mut item = output(&format!("direct-{index}"));- let mut call = ExecutedToolCall::new("direct_tool".to_string(), arguments.clone());- call.set_tool_result_metadata(ToolResultMetadata::new(&json!({"id": index})));- recorder.attach_direct_call_to_output(- &mut item,- Some((call, recorder.reserve_direct_call().unwrap())),- );- history.push(item);- }- assert!(- history[direct_start..]- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- > 128 * 1024+ recorder+ .retained_direct_metadata_bytes+ .store(MAX_RETAINED_DIRECT_METADATA_BYTES, Ordering::Relaxed);++ let direct_metadata = json!({"openai/resource_access": {"data": "d".repeat(900 * 1024)}});+ let mut direct_call = ExecutedToolCall::new("direct_tool".to_string(), json!({}));+ direct_call.set_tool_result_metadata(ToolResultMetadata::new(&direct_metadata));+ let ordinary_direct = output("direct");+ let mut direct = ordinary_direct.clone();+ recorder.attach_direct_call_to_output(+ &mut direct,+ Some((direct_call, recorder.reserve_direct_call().unwrap())),);+ assert!(direct.executed_tool_call_metadata().is_none());++ let cell = CellId::new("code-cell".to_string());+ recorder.start_cell(&cell, "exec");+ record_nested_call(&recorder, &cell, "nested");+ let code_metadata = json!({"openai/resource_access": {"data": "c".repeat(1400 * 1024)}});+ let source = ToolCallSource::CodeMode {+ cell_id: cell.as_str().to_string(),+ runtime_tool_call_id: "nested".to_string(),+ };+ assert!(recorder.record_tool_result_metadata(&source, "nested", &code_metadata));+ recorder.finish_cell_recording(&cell);+ let ordinary_code = ResponseItem::from(ResponseInputItem::CustomToolCallOutput {+ call_id: "exec".to_string(),+ name: None,+ output: FunctionCallOutputPayload::from_text("ordinary result".to_string()),+ });+ let history = vec![direct, exec_input("exec"), ordinary_code.clone()];- let mut code_mode_only = history[..direct_start].to_vec();- recorder.attach_to_compaction_prompt(&mut code_mode_only);let mut compact = history.clone();recorder.attach_to_compaction_prompt(&mut compact);- assert_eq!(&compact[direct_start..], &history[direct_start..]);- assert_eq!(&compact[..direct_start], &code_mode_only);assert!(- compact[..direct_start]+ compact.iter().map(executed_tool_call_metadata_bytes).sum::<usize>()- <= 2 * 1024 * 1024+ > 2 * 1024 * 1024);- let mut newest = exec_output("exec-95");- let mut newest_call = ExecutedToolCall::new("nested_tool".to_string(), arguments);- newest_call.set_tool_result_metadata(ToolResultMetadata::new(&json!({- "provider": "x".repeat(24 * 1024),- })));- newest.append_executed_tool_calls(vec![newest_call]);- newest.set_tool_call_cell_id("exec-95");- newest.mark_tool_calls_complete();- assert_eq!(compact[direct_start - 1], newest);- let oldest = serde_json::to_value(&compact[1]).unwrap();- assert!(- oldest["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"]- .as_str()- .is_some_and(|marker| marker.starts_with("omitted_due_to_size_limit (overage_bytes=")),+ let direct_wire = serde_json::to_value(&compact[0]).unwrap();+ let code_wire = serde_json::to_value(&compact[2]).unwrap();+ assert_eq!(+ direct_wire["output"],+ serde_json::to_value(&ordinary_direct).unwrap()["output"]+ );+ assert_eq!(+ code_wire["output"],+ serde_json::to_value(&ordinary_code).unwrap()["output"]+ );+ assert_eq!(+ direct_wire["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],+ direct_metadata);- assert_eq!(tool_calls_complete(&compact[1]), Some(true));- let mut retry = history;- recorder.attach_to_compaction_prompt(&mut retry);- assert_eq!(retry, compact);+ assert_eq!(+ code_wire["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],+ code_metadata+ );+ assert_eq!(tool_calls_complete(&compact[2]), Some(true));++ let mut sampled = history.clone();+ recorder.attach_to_prompt(&mut sampled, &mut HashMap::new());+ assert_eq!(sampled, compact);++ // A smaller window still has the full Code Mode result and its completion marker.+ let mut next = history[1..].to_vec();+ recorder.attach_to_prompt(&mut next, &mut HashMap::new());+ assert_eq!(next[1], compact[2]);+}++#[test]+fn failed_compaction_preserves_observations_absent_from_trimmed_retries() {+ let recorder = new_recorder(InitialHistory::New);+ recorder+ .retained_direct_metadata_bytes+ .store(MAX_RETAINED_DIRECT_METADATA_BYTES, Ordering::Relaxed);+ let mut direct = output("direct");+ let mut direct_call = ExecutedToolCall::new("direct_tool".to_string(), json!({}));+ direct_call.set_tool_result_metadata(ToolResultMetadata::new(&json!({"resource": "old"})));+ recorder.attach_direct_call_to_output(+ &mut direct,+ Some((direct_call, recorder.reserve_direct_call().unwrap())),+ );+ assert!(direct.executed_tool_call_metadata().is_none());+ let mut history = vec![direct.clone()];+ for origin in ["old", "recent"] {+ let cell = CellId::new(origin.to_string());+ recorder.start_cell(&cell, origin);+ record_nested_call(&recorder, &cell, "nested");+ recorder.finish_cell_recording(&cell);+ history.extend([exec_input(origin), exec_output(origin)]);+ }+ let mut full_attempt = history.clone();+ recorder.attach_to_compaction_prompt(&mut full_attempt);+ assert_eq!(tool_calls_complete(&full_attempt[0]), Some(true));+ assert_eq!(tool_calls_complete(&full_attempt[2]), Some(true));++ let source = ToolCallSource::CodeMode {+ cell_id: "recent".to_string(),+ runtime_tool_call_id: "runtime".to_string(),+ };+ let large_metadata = json!({"provider": "x".repeat(2100 * 1024)});+ assert!(recorder.record_tool_result_metadata(&source, "nested", &large_metadata));+ let mut trimmed_attempt = history[3..].to_vec();+ recorder.attach_to_compaction_prompt(&mut trimmed_attempt);+ assert_eq!(tool_calls_complete(&trimmed_attempt[1]), Some(true));+ let encoded = serde_json::to_value(&trimmed_attempt[1]).unwrap();+ assert_eq!(+ encoded["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],+ large_metadata+ );++ // Failed retries do not install the trimmed history or lose older observations.+ let mut expected = full_attempt;+ expected[3..].clone_from_slice(&trimmed_attempt);+ let mut resumed = history.clone();+ recorder.attach_to_prompt(&mut resumed, &mut HashMap::new());+ assert_eq!(resumed, expected);++ // Normal sampling in the smaller window can prune the old observation.+ recorder.attach_to_prompt(&mut history[3..], &mut HashMap::new());+ let mut old = vec![direct.clone(), exec_input("old"), exec_output("old")];+ recorder.attach_to_prompt(&mut old, &mut HashMap::new());+ assert_eq!(old, vec![direct, exec_input("old"), exec_output("old")]);}#[test]@@ -323,6 +304,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {Some((call.clone(), recorder.reserve_direct_call().unwrap())),);let mut expected_first = output("first");+ expected_first.set_id(first.id().cloned());expected_first.append_executed_tool_calls(vec![call.clone()]);expected_first.mark_tool_calls_complete();assert_eq!(first, expected_first);@@ -356,6 +338,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {&mut resource_only_output,Some((call.clone(), recorder.reserve_direct_call().unwrap())),);+ expected_resource_only.set_id(resource_only_output.id().cloned());assert_eq!(resource_only_output, expected_resource_only);assert_eq!(recorder@@ -380,6 +363,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {Some((call.clone(), recorder.reserve_direct_call().unwrap())),);let mut expected_second = output("second");+ expected_second.set_id(second.id().cloned());expected_second.append_executed_tool_calls(vec![ExecutedToolCall::new("test_tool".to_string(),json!({"argument": "kept"}),@@ -704,79 +688,6 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {assert!(!state.cells.contains_key(&cell_id));}-#[test]-fn executed_tool_call_recorder_bounds_retained_history_and_keeps_latest_calls() {- let recorder = new_recorder(InitialHistory::Forked(Vec::new()));- let mut history = Vec::new();- let arguments = json!({ "payload": "x".repeat(7 * 1024) });- let argument_bytes = serialized_json_bytes(&arguments).expect("tool arguments must serialize");- let cell_count = 100;- let calls_per_cell = 4;- assert!(argument_bytes < MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);- assert!(- argument_bytes * calls_per_cell < MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT- );- assert!(argument_bytes * calls_per_cell * cell_count > 2 * 1024 * 1024);- let mut prompt = Vec::new();-- for index in 0..cell_count {- let call_id = format!("retained-{index}");- let cell_id = CellId::new(format!("retained-cell-{index}"));- recorder.start_cell(&cell_id, &call_id);- let expected_calls = (0..calls_per_cell)- .map(|nested_index| {- ExecutedToolCall::new(- format!("retained_tool_{index}_{nested_index}"),- arguments.clone(),- )- })- .collect::<Vec<_>>();- for (nested_index, call) in expected_calls.iter().enumerate() {- recorder.record_nested_tool_call(- cell_id.clone(),- format!("nested-{index}-{nested_index}"),- call.clone(),- argument_bytes,- );- }- recorder.finish_cell_recording(&cell_id);- history.extend([exec_input(&call_id), exec_output(&call_id)]);- prompt = history.clone();- assert!(recorder.attach_pending_to_prompt(&mut prompt, &mut HashMap::new()));- codex_protocol::models::bound_executed_tool_calls_for_prompt(&mut prompt);- let latest_calls = prompt- .last()- .and_then(ResponseItem::executed_tool_call_metadata)- .and_then(|metadata| metadata.executed_tool_calls.as_ref())- .expect("latest tool calls must remain in retained metadata");- assert_eq!(latest_calls, &expected_calls);- }-- let state = recorder.lock_state();- let state = state.as_ref().unwrap();- let retained_bytes = state- .retained_calls- .values()- .map(|retained| serialized_json_bytes(&retained.calls))- .sum::<serde_json::Result<usize>>()- .expect("retained calls must serialize");- assert!(retained_bytes <= 2 * 1024 * 1024);-- let metadata = prompt- .iter()- .filter_map(ResponseItem::executed_tool_call_metadata)- .filter_map(|metadata| metadata.executed_tool_calls.as_ref())- .flatten()- .map(|call| serde_json::to_value(call).expect("retained call must serialize"))- .collect::<Vec<_>>();- assert!(metadata.len() < cell_count * calls_per_cell);- // Dropped outputs do not add their omission counts to unrelated surviving calls.- assert!(metadata.iter().all(|call| {- let omitted = &call["arguments"]["_codex_executed_tool_call_truncated"]["omitted_calls"];- omitted.is_null() || *omitted == json!(calls_per_cell - 1)- }));-}-#[test]fn tool_call_completeness_requires_finished_lossless_recording() {for scenario in ["unfinished", "unobserved", "late_call"] {@@ -1047,64 +958,6 @@ fn tool_call_completeness_survives_waits_without_changing_deltas() {}}-#[test]-fn unrelated_raw_overflow_retains_a_complete_exec_within_the_request_budget() {- let request_budget = 2 * 1024 * 1024;- let recorder = new_recorder(InitialHistory::New);- let cell = CellId::new("clean-overflow-cell".to_string());- recorder.start_cell(&cell, "exec-clean");- let clean_call = record_nested_call(&recorder, &cell, "nested-clean");- recorder.finish_cell_recording(&cell);-- let mut unrelated = output("direct-oversized");- let arguments = json!("x".repeat(7 * 1024));- assert!(serialized_json_bytes(&arguments).unwrap() <= MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);- unrelated.append_executed_tool_calls(- (0..request_budget / (7 * 1024) + 1)- .map(|index| ExecutedToolCall::new(format!("direct-{index}"), arguments.clone()))- .collect(),- );- let original = [- unrelated,- exec_input("exec-clean"),- exec_output("exec-clean"),- ];- let mut prompt = original.clone();- assert!(- prompt- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- > request_budget- );- recorder.attach_to_prompt(&mut prompt, &mut HashMap::new());- let metadata = prompt[2]- .executed_tool_call_metadata()- .expect("the later clean output must retain its calls");- assert_eq!(metadata.executed_tool_calls, Some(vec![clean_call]));- assert_eq!(metadata.tool_calls_complete, Some(true));- assert!(- prompt[0]- .executed_tool_call_metadata()- .and_then(|metadata| metadata.executed_tool_calls.as_ref())- .is_some_and(|calls| calls.iter().any(|call| matches!(- call.arguments(),- ExecutedToolCallArguments::Truncated { .. }- )))- );- assert!(- prompt- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- <= request_budget- );-- let mut retry = original;- recorder.attach_to_prompt(&mut retry, &mut HashMap::new());- assert_eq!(retry, prompt);-}-#[test]fn paginated_history_allows_fresh_origins_but_rejects_known_ids() {for origin in ["fresh-exec", "old-exec"] {@@ -1298,72 +1151,46 @@ fn completeness_rejects_direct_id_collision_and_late_calls() {}#[test]-fn request_truncation_prevents_completion_after_compaction() {+fn newly_normalized_arguments_keep_later_wait_incomplete() {let recorder = new_recorder(InitialHistory::New);- let cell_id = CellId::new("compacted-cell".to_string());- recorder.start_cell(&cell_id, "exec");-+ let cell = CellId::new("active-cell".to_string());+ recorder.start_cell(&cell, "exec");let arguments = json!({- "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - r#"{"payload":""}"#.len()),+ "_codex_executed_tool_call_truncated": true,+ "padding": "x".repeat(8_120),+ })+ .to_string();+ let (call, original_bytes) = recorded_call(&ToolCall {+ tool_name: codex_tools::ToolName::plain("nested_tool"),+ call_id: "nested".to_string(),+ payload: ToolPayload::Function { arguments },+ encrypted_function_args: None,});- for index in 0..4 {- recorder.record_nested_tool_call(- cell_id.clone(),- format!("nested-{index}"),- ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),- MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,- );- }-- let mut initial = vec![exec_input("exec"), exec_output("exec")];- for index in 0..63 {- let origin = format!("other-{index}");- let other_cell = CellId::new(origin.clone());- recorder.start_cell(&other_cell, &origin);- for nested in 0..4 {- recorder.record_nested_tool_call(- other_cell.clone(),- format!("other-{index}-{nested}"),- ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),- MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,- );- }- recorder.finish_cell_recording(&other_cell);- initial.extend([exec_input(&origin), exec_output(&origin)]);- }- assert!(recorder.attach_pending_to_prompt(&mut initial, &mut HashMap::new()));+ assert!(original_bytes <= MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);+ assert!(+ serialized_json_bytes(call.arguments()).unwrap() > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES+ );+ recorder.record_nested_tool_call(cell.clone(), "nested".to_string(), call, original_bytes);+ let mut initial = [exec_input("exec"), exec_output("exec")];+ recorder.attach_to_prompt(&mut initial, &mut HashMap::new());assert!(initial[1].executed_tool_call_metadata()- .and_then(|metadata| metadata.executed_tool_calls.as_ref())- .is_some_and(|calls| calls.iter().any(|call| matches!(+ .unwrap()+ .executed_tool_calls+ .as_ref()+ .unwrap()+ .iter()+ .any(|call| matches!(call.arguments(),ExecutedToolCallArguments::Truncated { .. }- )))- );- let source = ToolCallSource::CodeMode {- cell_id: cell_id.as_str().to_string(),- runtime_tool_call_id: "runtime-call".to_string(),- };- for index in 0..4 {- assert!(!recorder.record_tool_result_metadata(- &source,- &format!("nested-{index}"),- &json!({}),- ));- }-- recorder.attach_pending_to_prompt(&mut [], &mut HashMap::new());- recorder.register_cell(&cell_id, "wait");- recorder.finish_cell_recording(&cell_id);- let mut final_output = [wait_input("wait", &cell_id), output("wait")];- recorder.attach_pending_to_prompt(&mut final_output, &mut HashMap::new());- assert_eq!(- final_output[1]- .executed_tool_call_metadata()- .and_then(|metadata| metadata.tool_calls_complete),- None,+ )));+ recorder.register_cell(&cell, "wait");+ recorder.finish_cell_recording(&cell);+ let mut wait = [wait_input("wait", &cell), output("wait")];+ recorder.attach_to_prompt(&mut wait, &mut HashMap::new());+ assert_eq!(tool_calls_complete(&wait[1]), None);}#[test]@@ -1720,7 +1547,31 @@ fn late_truncated_metadata_is_not_attached_to_ambiguous_outputs() {}#[test]-fn late_truncated_metadata_obeys_the_existing_request_budget() {+fn late_raw_metadata_is_not_attached_after_duplicate_outputs() {+ let recorder = new_recorder(InitialHistory::New);+ let cell = CellId::new("ambiguous-cell".to_string());+ recorder.start_cell(&cell, "exec");+ record_nested_call(&recorder, &cell, "nested");+ let mut duplicate = [exec_input("exec"), exec_output("exec"), exec_output("exec")];+ recorder.attach_to_prompt(&mut duplicate, &mut HashMap::new());++ let source = ToolCallSource::CodeMode {+ cell_id: cell.as_str().to_string(),+ runtime_tool_call_id: "nested".to_string(),+ };+ assert!(!recorder.record_tool_result_metadata(+ &source,+ "nested",+ &json!({"openai/resource_access": {"resources": ["result"]}}),+ ));+ let mut retry = [exec_input("exec"), exec_output("exec")];+ recorder.attach_to_prompt(&mut retry, &mut HashMap::new());+ assert!(!retry[1].has_tool_result_metadata());+ assert_eq!(tool_calls_complete(&retry[1]), None);+}++#[test]+fn late_truncated_metadata_preserves_large_result_on_retry() {let recorder = new_recorder(InitialHistory::New);let cell = CellId::new("late-truncated-cell".to_string());recorder.start_cell(&cell, "exec");@@ -1744,7 +1595,7 @@ fn late_truncated_metadata_obeys_the_existing_request_budget() {let actual = serde_json::to_value(&retry[1]).unwrap();assert_eq!(actual["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],- json!({"openai/resource_access": {"resources": ["result"]}}),+ metadata,);}}@@ -1804,142 +1655,6 @@ fn late_truncated_metadata_is_not_reused_after_budget_changes_calls() {);}-#[test]-fn untracked_history_budget_loss_keeps_later_wait_incomplete() {- let recorder = new_recorder(InitialHistory::New);- let cell = CellId::new("running-cell".to_string());- recorder.start_cell(&cell, "exec");- recorder.record_nested_tool_call(- cell.clone(),- "nested".to_string(),- ExecutedToolCall::new("nested_tool".to_string(), json!("x".repeat(8190))),- /*original_bytes*/ 8192,- );- let mut prompt = vec![exec_input("exec"), exec_output("exec")];- let untracked_count = 256;- let per_output_budget = 2 * 1024 * 1024 / untracked_count;- let mut empty_output = output("untracked");- empty_output.append_executed_tool_calls(vec![ExecutedToolCall::new(- "other_tool".to_string(),- json!(""),- )]);- // Fill the budget with intact unmanaged outputs, leaving no room for the tracked record.- let payload_bytes = per_output_budget - executed_tool_call_metadata_bytes(&empty_output);- for index in 0..untracked_count {- let mut item = output(&format!("untracked-{index}"));- item.append_executed_tool_calls(vec![ExecutedToolCall::new(- "other_tool".to_string(),- json!("x".repeat(payload_bytes)),- )]);- assert_eq!(executed_tool_call_metadata_bytes(&item), per_output_budget);- prompt.push(item);- }- recorder.attach_to_prompt(&mut prompt, &mut HashMap::new());- assert!(prompt[1].executed_tool_call_metadata().is_none());-- recorder.attach_to_prompt(&mut [], &mut HashMap::new());- recorder.register_cell(&cell, "wait");- recorder.finish_cell_recording(&cell);- let mut wait = [wait_input("wait", &cell), output("wait")];- recorder.attach_to_prompt(&mut wait, &mut HashMap::new());- assert_eq!(tool_calls_complete(&wait[1]), None);-}--#[test]-fn result_metadata_shedding_preserves_completion_after_compaction() {- let recorder = new_recorder(InitialHistory::New);- let cell_id = CellId::new("compacted-cell".to_string());- recorder.start_cell(&cell_id, "exec");-- let call_count = 79;- let argument_bytes = MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT / call_count - 64;- let arguments = json!({- "payload": "x".repeat(argument_bytes - r#"{"payload":""}"#.len()),- });- for index in 0..call_count {- recorder.record_nested_tool_call(- cell_id.clone(),- format!("nested-{index}"),- ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),- argument_bytes,- );- }- let source = ToolCallSource::CodeMode {- cell_id: cell_id.as_str().to_string(),- runtime_tool_call_id: "runtime-call".to_string(),- };- let mut retry_cache = HashMap::new();- recorder.attach_pending_to_prompt(- &mut [exec_input("exec"), exec_output("exec")],- &mut retry_cache,- );- // Each snapshot fits alone; together they push the calls over the aggregate budget.- let large_metadata = json!({ "provider_data": "x".repeat(26 * 1024) });- for index in (0..call_count).filter(|index| *index != 1) {- assert!(recorder.record_tool_result_metadata(- &source,- &format!("nested-{index}"),- &large_metadata,- ));- }-- assert!(recorder.record_tool_result_metadata(- &source,- "nested-1",- &json!({ "status": "unavailable" })- ));- let mut initial = [exec_output("exec")];- assert!(recorder.attach_pending_to_prompt(&mut initial, &mut retry_cache));- let calls = initial[0]- .executed_tool_call_metadata()- .and_then(|metadata| metadata.executed_tool_calls.as_ref())- .expect("metadata shedding must preserve recorded calls");- let mut expected_calls =- vec![ExecutedToolCall::new("nested_tool".to_string(), arguments); call_count];- for call in &mut expected_calls {- call.set_tool_result_metadata(ToolResultMetadata::new(&large_metadata));- }- expected_calls[1]- .set_tool_result_metadata(ToolResultMetadata::new(&json!({ "status": "unavailable" })));- let mut unbounded = exec_output("exec");- unbounded.append_executed_tool_calls(expected_calls.clone());- unbounded.set_tool_call_cell_id("exec");- let overage = executed_tool_call_metadata_bytes(&unbounded) - 2 * 1024 * 1024;- expected_calls[0].set_tool_result_metadata(ToolResultMetadata::new(&json!(format!(- "omitted_due_to_size_limit (overage_bytes={overage})"- ))));- assert_eq!(calls, &expected_calls);- let mut retry = [exec_output("exec")];- assert!(recorder.attach_pending_to_prompt(&mut retry, &mut retry_cache));- assert_eq!(retry, initial);-- // A different call can still attach a small result after the oversized metadata is shed.- let metadata = json!({ "id": "R2" });- assert!(recorder.record_tool_result_metadata(&source, "nested-2", &metadata));- let mut expected_calls = calls.clone();- expected_calls[2].set_tool_result_metadata(ToolResultMetadata::new(&metadata));- let mut expected = exec_output("exec");- expected.append_executed_tool_calls(expected_calls);- expected.set_tool_call_cell_id("exec");- let mut retry = [exec_output("exec")];- assert!(recorder.attach_pending_to_prompt(&mut retry, &mut retry_cache));- assert_eq!(retry, [expected]);-- recorder.attach_pending_to_prompt(&mut [], &mut retry_cache);- assert!(retry_cache.is_empty());- assert!(!recorder.record_tool_result_metadata(&source, "nested-2", &metadata));- recorder.register_cell(&cell_id, "wait");- recorder.finish_cell_recording(&cell_id);- let mut final_output = [wait_input("wait", &cell_id), output("wait")];- recorder.attach_pending_to_prompt(&mut final_output, &mut HashMap::new());- assert_eq!(- final_output[1]- .executed_tool_call_metadata()- .and_then(|metadata| metadata.tool_calls_complete),- Some(true),- );-}-#[test]fn mapping_pressure_preserves_existing_cells_and_late_partial_records() {let recorder = new_recorder(InitialHistory::New);diff --git a/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs b/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rsindex 4d0f1ea7f1..23f2033d25 100644--- a/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs+++ b/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs@@ -1,6 +1,7 @@//! Tests Direct metadata admission and permit lifetimes.//! Metadata limits must leave ordinary tool outputs unchanged.+use codex_protocol::ResponseItemId;use codex_protocol::models::FunctionCallOutputPayload;use codex_protocol::models::ResponseInputItem;use pretty_assertions::assert_eq;@@ -15,6 +16,118 @@ fn output(call_id: &str) -> ResponseItem {})}+#[test]+fn direct_request_uses_live_window_after_persisted_budget_is_exhausted() {+ let mut features = Features::default();+ features.enable(Feature::ExecutedToolCallMetadata);+ let recorder = ExecutedToolCalls::new(&features, &InitialHistory::New);+ recorder+ .retained_direct_metadata_bytes+ .store(MAX_RETAINED_DIRECT_METADATA_BYTES, Ordering::Relaxed);+ let metadata = json!({"openai/resource_access": {"connector": "example"}});+ let make_output = |id: &str| {+ let mut call = ExecutedToolCall::new("connector_tool".to_string(), json!({}));+ call.set_tool_result_metadata(ToolResultMetadata::new(&metadata));+ let mut item = output(id);+ recorder.attach_direct_call_to_output(+ &mut item,+ Some((call, recorder.reserve_direct_call().unwrap())),+ );+ item+ };+ let old = make_output("old-window");+ let mut first = vec![old.clone()];+ recorder.attach_to_prompt(&mut first, &mut HashMap::new());+ let current = make_output("new-window");+ assert!(current.executed_tool_call_metadata().is_none());+ let serialized = serde_json::to_string(&codex_history::RolloutItem::ResponseItem(+ current.clone().into(),+ ))+ .unwrap();+ assert!(!serialized.contains("example"));++ // The input to the next window no longer contains the old output.+ let mut next = vec![current.clone()];+ recorder.attach_to_prompt(&mut next, &mut HashMap::new());+ for item in [&first[0], &next[0]] {+ let encoded = serde_json::to_value(item).unwrap();+ assert_eq!(encoded["output"], "tool result");+ assert_eq!(+ encoded["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"],+ metadata,+ );+ }+ let mut pruned = vec![old];+ recorder.attach_to_compaction_prompt(&mut pruned);+ assert!(pruned[0].executed_tool_call_metadata().is_none());++ // Capture toggles must not revive a previous recorder's live-only metadata.+ recorder.refresh(&Features::default());+ recorder.refresh(&features);+ let mut after_refresh = vec![current];+ recorder.attach_to_prompt(&mut after_refresh, &mut HashMap::new());+ assert!(after_refresh[0].executed_tool_call_metadata().is_none());+}++#[test]+fn direct_metadata_follows_output_ids_with_reused_call_ids_and_reverse_completion() {+ for supplied_ids in [false, true] {+ let mut features = Features::default();+ features.enable(Feature::ExecutedToolCallMetadata);+ let recorder = ExecutedToolCalls::new(&features, &InitialHistory::New);+ recorder+ .retained_direct_metadata_bytes+ .store(MAX_RETAINED_DIRECT_METADATA_BYTES, Ordering::Relaxed);+ let metadata = [json!({"result": "first"}), json!({"result": "second"})];+ let mut prepared = metadata+ .iter()+ .map(|metadata| {+ let mut call = ExecutedToolCall::new("connector_tool".to_string(), json!({}));+ call.set_tool_result_metadata(ToolResultMetadata::new(metadata));+ Some((call, recorder.reserve_direct_call().unwrap()))+ })+ .collect::<Vec<_>>();+ let mut outputs = [output("reused"), output("reused")];+ let expected_ids = [+ ResponseItemId::with_suffix("fco", "first"),+ ResponseItemId::with_suffix("fco", "second"),+ ];+ if supplied_ids {+ for (item, id) in outputs.iter_mut().zip(&expected_ids) {+ item.set_id(Some(id.clone()));+ }+ }+ // Completion order and prompt order must not choose which observation belongs here.+ for index in [1, 0] {+ recorder.attach_direct_call_to_output(&mut outputs[index], prepared[index].take());+ assert!(outputs[index].executed_tool_call_metadata().is_none());+ if supplied_ids {+ assert_eq!(outputs[index].id(), Some(&expected_ids[index]));+ }+ }+ let ids = outputs.clone().map(|item| item.id().unwrap().clone());+ assert_ne!(ids[0], ids[1]);+ let mut request = outputs;+ for reversed in [false, true] {+ if reversed {+ request.reverse();+ }+ recorder.attach_to_prompt(&mut request, &mut HashMap::new());+ for item in &request {+ let index = usize::from(item.id() == Some(&ids[1]));+ let encoded = serde_json::to_value(item).unwrap();+ assert_eq!(encoded["call_id"], "reused");+ assert_eq!(encoded["output"], "tool result");+ assert_eq!(+ encoded["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]+ ["tool_result_metadata"],+ metadata[index],+ );+ }+ }+ }+}+#[test]fn direct_budget_keeps_an_omission_marker_when_it_fits() {for metadata in [@@ -50,6 +163,7 @@ fn direct_budget_keeps_an_omission_marker_when_it_fits() {Some((call, recorder.reserve_direct_call().unwrap())),);+ expected.set_id(item.id().cloned());assert_eq!(item, expected);assert_eq!(recorderdiff --git a/codex-rs/core/src/tools/metadata_metrics.rs b/codex-rs/core/src/tools/metadata_metrics.rsindex f4fee32b1f..caae89dacf 100644--- a/codex-rs/core/src/tools/metadata_metrics.rs+++ b/codex-rs/core/src/tools/metadata_metrics.rs@@ -11,20 +11,6 @@ const BYTE_BUCKETS: &[f64] = &[4194304.0, 8388608.0, 16777216.0,];-pub(super) fn bound_prompt_metadata(- items: &mut [ResponseItem],- bound: fn(&mut [ResponseItem]),- stage: &'static str,- metrics: Option<&MetricsClient>,-) {- let before = metrics.map(|_| metadata_bytes(items));- bound(items);- if let Some(before) = before {- // Measure only the budget operation: attaching observations can itself add bytes.- record_shedding(stage, before, metadata_bytes(items), metrics);- }-}-pub(crate) fn metadata_bytes(items: &[ResponseItem]) -> usize {items.iter().fold(0_usize, |bytes, item| {bytes.saturating_add(executed_tool_call_metadata_bytes(item))diff --git a/codex-rs/core/src/tools/metadata_metrics_tests.rs b/codex-rs/core/src/tools/metadata_metrics_tests.rsindex 253f2d16fb..5d9a1b6cc9 100644--- a/codex-rs/core/src/tools/metadata_metrics_tests.rs+++ b/codex-rs/core/src/tools/metadata_metrics_tests.rs@@ -1,17 +1,10 @@use super::*;use codex_otel::MetricsConfig;-use codex_protocol::models::ExecutedToolCall;-use codex_protocol::models::FunctionCallOutputPayload;-use codex_protocol::models::ResponseInputItem;-use codex_protocol::models::ToolResultMetadata;-use codex_protocol::models::bound_executed_tool_calls_for_prompt;-use codex_protocol::models::bound_executed_tool_calls_for_prompt_prioritizing_recent;use opentelemetry_sdk::metrics::InMemoryMetricExporter;use opentelemetry_sdk::metrics::data::AggregatedMetrics;use opentelemetry_sdk::metrics::data::MetricData;use opentelemetry_sdk::metrics::data::ScopeMetrics;use pretty_assertions::assert_eq;-use serde_json::json;use std::collections::BTreeMap;fn metrics() -> MetricsClient {@@ -48,57 +41,6 @@ fn samples(metrics: &MetricsClient) -> BTreeMap<String, (u64, f64)> {samples}-#[test]-fn prompt_reports_each_budget_application_without_changing_output() {- let metrics = metrics();- let original = (0..96)- .map(|index| {- let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {- call_id: format!("call_{index}"),- output: FunctionCallOutputPayload::from_text("unchanged output".to_string()),- });- let mut call = ExecutedToolCall::new("mcp__apps__read".to_string(), json!({}));- call.set_tool_result_metadata(ToolResultMetadata::new(&json!({- "openai/resource_access": {"resources": ["x".repeat(24_000)]},- })));- item.append_executed_tool_calls(vec![call]);- item.mark_tool_calls_complete();- item- })- .collect::<Vec<_>>();- let mut expected_samples = BTreeMap::new();- for (stage, bound) in [- (- "request",- bound_executed_tool_calls_for_prompt as fn(&mut [ResponseItem]),- ),- (- "retained",- bound_executed_tool_calls_for_prompt_prioritizing_recent,- ),- (- "compaction",- bound_executed_tool_calls_for_prompt_prioritizing_recent,- ),- ] {- let mut expected = original.clone();- bound(&mut expected);- let shed = metadata_bytes(&original) - metadata_bytes(&expected);- assert!(shed > 0);- let mut actual = original.clone();- bound_prompt_metadata(&mut actual, bound, stage, Some(&metrics));- assert_eq!(actual, expected);- // Reapplying an already-satisfied budget must not add a zero-byte sample.- bound_prompt_metadata(&mut actual, bound, stage, Some(&metrics));- assert_eq!(actual, expected);- let mut without_metrics = original.clone();- bound_prompt_metadata(&mut without_metrics, bound, stage, /*metrics*/ None);- assert_eq!(without_metrics, expected);- expected_samples.insert(stage.to_string(), (1, shed as f64));- }- assert_eq!(samples(&metrics), expected_samples);-}-#[test]fn direct_retention_reports_only_positive_known_shedding() {let metrics = metrics();diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rsindex 4094ed06f3..eb0802902a 100644--- a/codex-rs/core/tests/suite/code_mode.rs+++ b/codex-rs/core/tests/suite/code_mode.rs@@ -2330,11 +2330,11 @@ async fn result_metadata_preserves_results_within_request_budget("payload": "l".repeat(31 * 1024),"openai/resource_access": resource_access,}),- serde_json::json!({ "payload": "m".repeat(20 * 1024) }),- serde_json::json!({ "payload": "m".repeat(20 * 1024) }),- serde_json::json!({ "payload": "m".repeat(20 * 1024) }),- serde_json::json!({ "payload": "m".repeat(20 * 1024) }),- serde_json::json!({ "payload": "m".repeat(20 * 1024) }),+ serde_json::json!({ "payload": "m".repeat(450 * 1024) }),+ serde_json::json!({ "payload": "m".repeat(450 * 1024) }),+ serde_json::json!({ "payload": "m".repeat(450 * 1024) }),+ serde_json::json!({ "payload": "m".repeat(450 * 1024) }),+ serde_json::json!({ "payload": "m".repeat(450 * 1024) }),serde_json::json!({"payload": "o".repeat(40 * 1024),"openai/resource_access": {@@ -2349,8 +2349,8 @@ async fn result_metadata_preserves_results_within_request_budget(.iter().map(|metadata| serde_json::to_vec(metadata).unwrap().len()).collect::<Vec<_>>();- assert!(metadata_sizes.iter().sum::<usize>() > 128 * 1024);- assert!(metadata_sizes.iter().sum::<usize>() < 1024 * 1024);+ assert!(metadata_sizes.iter().sum::<usize>() > 2 * 1024 * 1024);+ assert!(metadata_sizes.iter().sum::<usize>() < 15 * 1024 * 1024);assert!(serde_json::to_vec(&result_metadata[6]["openai/resource_access"])?.len() > 32 * 1024);for (arguments, metadata) in arguments.iter().zip(&result_metadata) {let result = serde_json::json!({@@ -2488,7 +2488,7 @@ async fn result_metadata_preserves_results_within_request_budget(.iter().map(codex_protocol::models::executed_tool_call_metadata_bytes).sum::<usize>()- <= 2 * 1024 * 1024+ > 2 * 1024 * 1024);let captured = serde_json::to_value(captured)?;for (input, expected_metadata) in [diff --git a/codex-rs/core/tests/suite/direct_tool_metadata.rs b/codex-rs/core/tests/suite/direct_tool_metadata.rsindex 65c03e3b02..22ab2c4a25 100644--- a/codex-rs/core/tests/suite/direct_tool_metadata.rs+++ b/codex-rs/core/tests/suite/direct_tool_metadata.rs@@ -1,6 +1,9 @@//! Direct-call metadata coverage, including malformed calls and metadata budgets.use anyhow::Result;+use codex_core::ForkSnapshot;+use codex_core::StartThreadOptions;+use codex_core::TurnInputRequest;use codex_features::Feature;use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;use codex_model_provider::RemoteCompactionSupport;@@ -23,6 +26,7 @@ use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::Op;+use codex_protocol::user_input::UserInput;use core_test_support::apps_test_server::configure_search_capable_model;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;@@ -495,7 +499,6 @@ async fn direct_function_and_tool_search_mark_complete_attempts() -> Result<()> {skip_if_no_network!(Ok(()));- let request_budget = 2 * 1024 * 1024;let server = start_mock_server().await;let mut builder = test_codex().with_config(move |config| {configure_search_capable_model(config);@@ -620,25 +623,27 @@ async fn direct_function_and_tool_search_mark_complete_attempts(}));}- assert!(metadata_bytes <= request_budget);if budget_calls > 0 {assert!(metadata_bytes > 128 * 1024);}Ok(())}+#[test_case(false; "ungranted_provider")]+#[test_case(true; "granted_provider")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provider() -> Result<()>-{+async fn direct_metadata_limit_respects_provider_support(+ include_internal_metadata: bool,+) -> Result<()> {skip_if_no_network!(Ok(()));let server = start_mock_server().await;let apps = AppsTestServer::mount(&server).await?;- let raw_metadata = json!({"openai/resource_access": {"payload": "x".repeat(600 * 1024)}});- let raw_bytes = serde_json::to_vec(&raw_metadata)?.len();+ fn metadata_for_query(query: &str) -> Value {+ json!({"openai/resource_access": {"payload": "x".repeat(600 * 1024), "query": query}})+ }+ let raw_bytes = serde_json::to_vec(&metadata_for_query("first"))?.len();assert!(raw_bytes < 1024 * 1024);assert!(raw_bytes * 2 > 1024 * 1024);- assert!(raw_bytes * 2 < 2 * 1024 * 1024);- let fixture_metadata = raw_metadata.clone();Mock::given(method("POST")).and(path_regex("^/api/codex/ps/mcp/?$")).and(body_partial_json(json!({"method": "tools/call"})))@@ -651,7 +656,7 @@ async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provi"jsonrpc": "2.0", "id": body["id"],"result": {"content": [{"type": "text", "text": format!("result for {query}")}],- "_meta": fixture_metadata,+ "_meta": metadata_for_query(query),"isError": false}}))@@ -664,35 +669,56 @@ async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provi.respond_with(ResponseTemplate::new(/*s*/ 200)).mount(&server).await;- let responses = mount_sse_sequence(- &server,- vec![- sse(vec![- ev_response_created("resp-1"),- ev_function_call_with_namespace(- "first",- SEARCH_CALENDAR_NAMESPACE,- SEARCH_CALENDAR_LIST_TOOL,- r#"{"query":"first"}"#,- ),- ev_completed("resp-1"),- ]),- sse(vec![- ev_response_created("resp-2"),+ let mut events = vec![+ sse(vec![+ ev_response_created("resp-1"),+ ev_function_call_with_namespace(+ "first",+ SEARCH_CALENDAR_NAMESPACE,+ SEARCH_CALENDAR_LIST_TOOL,+ r#"{"query":"first"}"#,+ ),+ ev_completed("resp-1"),+ ]),+ sse(vec![+ ev_response_created("resp-2"),+ ev_function_call_with_namespace(+ "second",+ SEARCH_CALENDAR_NAMESPACE,+ SEARCH_CALENDAR_LIST_TOOL,+ r#"{"query":"second"}"#,+ ),+ ev_completed("resp-2"),+ ]),+ sse(vec![ev_response_created("resp-3"), ev_completed("resp-3")]),+ ];+ if include_internal_metadata {+ for query in ["fork", "resume"] {+ events.push(sse(vec![+ ev_response_created(&format!("resp-{query}")),ev_function_call_with_namespace(- "second",+ query,SEARCH_CALENDAR_NAMESPACE,SEARCH_CALENDAR_LIST_TOOL,- r#"{"query":"second"}"#,+ &json!({"query": query}).to_string(),),- ev_completed("resp-2"),- ]),- sse(vec![ev_response_created("resp-3"), ev_completed("resp-3")]),- ],- )- .await;- let mut builder = search_capable_apps_builder(apps.chatgpt_base_url).with_config(|config| {- config.model_provider.include_internal_metadata = false;+ ev_completed(&format!("resp-{query}")),+ ]));+ events.push(sse(vec![+ ev_response_created(&format!("resp-{query}-done")),+ ev_completed(&format!("resp-{query}-done")),+ ]));+ }+ }+ let responses = mount_sse_sequence(&server, events).await;+ let mock_url = server.uri();+ let configure_metadata = move |config: &mut codex_core::config::Config| {+ assert_eq!(config.chatgpt_base_url, mock_url);+ assert_eq!(+ config.model_provider.base_url.as_deref(),+ Some(format!("{mock_url}/v1").as_str())+ );+ config.model_provider.include_internal_metadata = include_internal_metadata;config.analytics_enabled = Some(true);config.features@@ -706,7 +732,9 @@ async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provi.features.disable(Feature::CodeModeOnly).expect("disable code-mode-only tools");- });+ };+ let mut builder = search_capable_apps_builder(apps.chatgpt_base_url.clone())+ .with_config(configure_metadata.clone());// build() always selects the local test environment; all network destinations are the mock.let test = builder.build(&server).await?;assert!(test.codex.analytics_enabled());@@ -762,18 +790,20 @@ async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provirecorded_metadata["executed_tool_calls"][0]["arguments"],json!({"query": query}));- // An ungranted custom Responses provider must not receive internal result metadata.- assert!(- wire_metadata["executed_tool_calls"][0]- .get("tool_result_metadata")- .is_none()- );+ let wire_result_metadata =+ wire_metadata["executed_tool_calls"][0].get("tool_result_metadata");+ if include_internal_metadata {+ assert_eq!(wire_result_metadata, Some(&metadata_for_query(query)));+ } else {+ // An ungranted provider must not receive internal result metadata.+ assert!(wire_result_metadata.is_none());+ }}let first_metadata = tool_call_metadata(recorded_outputs[0].clone());let second_metadata = tool_call_metadata(recorded_outputs[1].clone());assert_eq!(first_metadata["executed_tool_calls"][0]["tool_result_metadata"],- raw_metadata+ metadata_for_query("first"));let marker = second_metadata["executed_tool_calls"][0]["tool_result_metadata"].as_str()@@ -784,5 +814,117 @@ async fn direct_metadata_limit_retains_marker_without_sending_it_to_custom_provi.and_then(|value| value.parse::<usize>().ok()).expect("marker should report omitted bytes");assert!(overage > 0);+ if !include_internal_metadata {+ return Ok(());+ }++ let rollout_path = test.codex.rollout_path().expect("rollout path");+ test.codex.shutdown_and_wait().await?;+ let rollout = tokio::fs::read_to_string(&rollout_path).await?;+ let rollout = rollout+ .lines()+ .map(serde_json::from_str::<Value>)+ .collect::<serde_json::Result<Vec<_>>>()?;+ for (call_id, expected) in [("first", &first_metadata), ("second", &second_metadata)] {+ let item = rollout+ .iter()+ .find(|line| {+ line["type"] == "response_item"+ && line["payload"]["type"] == "function_call_output"+ && line["payload"]["call_id"] == call_id+ })+ .expect("persisted tool output");+ assert_eq!(tool_call_metadata(item["payload"].clone()), *expected);+ }+ let forked = test+ .thread_manager+ .fork_legacy_thread(+ ForkSnapshot::Interrupted,+ StartThreadOptions::new(test.config.clone()),+ rollout_path.clone(),+ )+ .await?;+ wait_for_mcp_server(&forked.thread, CODEX_APPS_MCP_SERVER_NAME).await?;+ forked+ .thread+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "List events in the fork.".to_string(),+ text_elements: Vec::new(),+ }]))+ .await?;+ wait_for_event(&forked.thread, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ forked+ .thread+ .shutdown_and_wait()+ .await+ .expect("shutdown fork");++ let resumed = search_capable_apps_builder(apps.chatgpt_base_url)+ .with_config(configure_metadata)+ .resume(&server, test.home.clone(), rollout_path)+ .await+ .expect("resume original thread");+ wait_for_mcp_server(&resumed.codex, CODEX_APPS_MCP_SERVER_NAME)+ .await+ .expect("start resumed MCP server");+ resumed+ .submit_text_turn("List events after resume.")+ .await+ .expect("run resumed turn");+ resumed+ .codex+ .shutdown_and_wait()+ .await+ .expect("shutdown resumed thread");++ let requests = responses.requests();+ assert_eq!(requests.len(), 7);+ for request in &requests[3..] {+ for original in [&first_output, &second_output] {+ let call_id = original["call_id"].as_str().expect("call ID");+ let output = request.function_call_output(call_id);+ assert_eq!(output["output"], original["output"]);+ let passthrough = output.get("internal_chat_message_metadata_passthrough");+ assert!(+ passthrough+ .and_then(|meta| meta.get("executed_tool_calls"))+ .is_none()+ );+ assert!(+ passthrough+ .and_then(|meta| meta.get("tool_calls_complete"))+ .is_none()+ );+ }+ }+ for (request, query) in [(&requests[4], "fork"), (&requests[6], "resume")] {+ let output = request.function_call_output(query);+ assert!(+ output["output"]+ .to_string()+ .contains(&format!("result for {query}"))+ );+ let metadata = tool_call_metadata(output);+ assert_eq!(metadata["tool_calls_complete"], true);+ assert_eq!(+ metadata["executed_tool_calls"].as_array().map(Vec::len),+ Some(1)+ );+ assert_eq!(+ metadata["executed_tool_calls"][0]["name"],+ format!("{SEARCH_CALENDAR_NAMESPACE}{SEARCH_CALENDAR_LIST_TOOL}")+ );+ assert_eq!(+ metadata["executed_tool_calls"][0]["arguments"],+ json!({"query": query})+ );+ assert_eq!(+ metadata["executed_tool_calls"][0]["tool_result_metadata"],+ metadata_for_query(query)+ );+ }Ok(())}diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rsindex 318a4faa3d..e31b88fdbb 100644--- a/codex-rs/protocol/src/models.rs+++ b/codex-rs/protocol/src/models.rs@@ -49,9 +49,8 @@ pub use executed_tool_calls::ToolResultMetadata;pub use executed_tool_calls::ToolResultSource;pub use executed_tool_calls::ToolResultSources;pub use executed_tool_calls::bound_executed_tool_calls_for_message;-pub use executed_tool_calls::bound_executed_tool_calls_for_prompt;-pub use executed_tool_calls::bound_executed_tool_calls_for_prompt_prioritizing_recent;pub use executed_tool_calls::executed_tool_call_metadata_bytes;+pub use executed_tool_calls::normalize_executed_tool_call_arguments;pub use item_metadata::ContentItemKind;/// Controls the per-command sandbox override requested by a shell-like tool call.diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rsindex 676c0919d8..5bd758d75c 100644--- a/codex-rs/protocol/src/models/executed_tool_calls.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs@@ -13,8 +13,6 @@ const MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES: usize = 8 * 1024;const MAX_TOOL_RESULT_SOURCES: usize = 32;/// Maximum UTF-8 bytes for each source's `type` and `id` separately, not the source list.pub const MAX_TOOL_RESULT_SOURCE_FIELD_BYTES: usize = 128;-/// Maximum serialized warehouse-only attempted-tool metadata in one request.-const MAX_EXECUTED_TOOL_CALL_METADATA_BYTES: usize = 2 * 1024 * 1024;const RESOURCE_ACCESS_METADATA_KEY: &str = "openai/resource_access";const EXECUTED_TOOL_CALL_METADATA_FIELD_BYTES: usize = b"\"executed_tool_calls\":".len();const INTERNAL_CHAT_MESSAGE_METADATA_PASSTHROUGH_FIELD_BYTES: usize =@@ -75,23 +73,12 @@ impl InternalChatMessageMetadataPassthrough {}}-/// Bounds attempted-tool metadata fairly across the complete serialized request.-pub fn bound_executed_tool_calls_for_prompt(items: &mut [ResponseItem]) {- bound_executed_tool_calls_for_prompt_with_priority(items, /*prioritize_recent*/ false);-}--/// Bounds retained history without letting older calls displace the newest calls.-pub fn bound_executed_tool_calls_for_prompt_prioritizing_recent(items: &mut [ResponseItem]) {- items.reverse();- bound_executed_tool_calls_for_prompt_with_priority(items, /*prioritize_recent*/ true);- items.reverse();-}--fn bound_executed_tool_calls_for_prompt_with_priority(- items: &mut [ResponseItem],- prioritize_recent: bool,-) {+/// Bounds recorded arguments and clears completion when any call in a cell is truncated.+/// Returns cells whose arguments were newly truncated. Ordinary tool-call arguments and+/// outputs are not changed.+pub fn normalize_executed_tool_call_arguments(items: &mut [ResponseItem]) -> HashSet<String> {let mut damaged_cells = HashSet::new();+ let mut newly_truncated_cells = HashSet::new();for item in items.iter_mut() {let Some(metadata) = item.internal_chat_message_metadata_passthrough_mut()@@ -100,6 +87,7 @@ fn bound_executed_tool_calls_for_prompt_with_priority(continue;};let mut truncated = false;+ let mut newly_truncated = false;for call in metadata.executed_tool_calls.iter_mut().flatten() {let argument_bytes = serde_json::to_vec(&call.arguments).map(|bytes| bytes.len())@@ -111,6 +99,7 @@ fn bound_executed_tool_calls_for_prompt_with_priority(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,/*omitted_calls*/ None,);+ newly_truncated = true;}truncated |= call.truncation().is_some();}@@ -118,15 +107,12 @@ fn bound_executed_tool_calls_for_prompt_with_priority(metadata.tool_calls_complete = None;damaged_cells.extend(metadata.cell_id.clone());}+ if newly_truncated {+ newly_truncated_cells.extend(metadata.cell_id.clone());+ }}clear_damaged_cell_completeness(items, &damaged_cells);-- bound_executed_tool_calls_with_metadata_budget(- items,- MAX_EXECUTED_TOOL_CALL_METADATA_BYTES,- prioritize_recent,- /*whole_message*/ false,- );+ newly_truncated_cells}/// Bounds optional observations to the space left in the actual outgoing message.@@ -134,20 +120,6 @@ fn bound_executed_tool_calls_for_prompt_with_priority(pub fn bound_executed_tool_calls_for_message(items: &mut [ResponseItem],max_metadata_bytes: usize,-) {- bound_executed_tool_calls_with_metadata_budget(- items,- max_metadata_bytes,- /*prioritize_recent*/ false,- /*whole_message*/ true,- );-}--fn bound_executed_tool_calls_with_metadata_budget(- items: &mut [ResponseItem],- max_metadata_bytes: usize,- prioritize_recent: bool,- whole_message: bool,) {let mut damaged_cells = HashSet::new();@@ -155,19 +127,12 @@ fn bound_executed_tool_calls_with_metadata_budget(if total_metadata_bytes <= max_metadata_bytes {return;}- let mut remaining_bytes = shed_generic_result_metadata(- items,- max_metadata_bytes,- prioritize_recent,- whole_message,- total_metadata_bytes,- );-- // At the message limit, shed optional sources and recorded arguments before- // resource-access evidence. The prompt budget keeps its existing order.- if whole_message && metadata_bytes(items) > max_metadata_bytes {- let overage_bytes =- shed_result_sources(items, max_metadata_bytes, /*whole_message*/ true);+ let mut remaining_bytes =+ shed_generic_result_metadata(items, max_metadata_bytes, total_metadata_bytes);++ // Shed optional sources and recorded arguments before resource-access evidence.+ if metadata_bytes(items) > max_metadata_bytes {+ let overage_bytes = shed_result_sources(items, max_metadata_bytes);if overage_bytes > 0 {truncate_call_arguments_to_fit(items,@@ -178,13 +143,7 @@ fn bound_executed_tool_calls_with_metadata_budget(}remaining_bytes = metadata_bytes(items);}- shed_remaining_result_metadata(- items,- max_metadata_bytes,- prioritize_recent,- whole_message,- remaining_bytes,- );+ shed_remaining_result_metadata(items, max_metadata_bytes, remaining_bytes);// Recheck the serialized request rather than relying on the incremental size accounting.if metadata_bytes(items) <= max_metadata_bytes {@@ -198,21 +157,7 @@ fn bound_executed_tool_calls_with_metadata_budget(if metadata_bytes(items) <= max_metadata_bytes {return;}- // The whole-message path already handled sources and arguments before resources.- if !whole_message {- shed_result_sources(items, max_metadata_bytes, /*whole_message*/ false);- }-- if metadata_bytes(items) <= max_metadata_bytes {- return;- }-- distribute_remaining_budget(- items,- max_metadata_bytes,- prioritize_recent,- &mut damaged_cells,- );+ distribute_remaining_budget(items, max_metadata_bytes, &mut damaged_cells);clear_damaged_cell_completeness(items, &damaged_cells);}@@ -224,23 +169,13 @@ fn metadata_bytes(items: &[ResponseItem]) -> usize {type ResultMetadataEntry<'a> = (usize, usize, usize, &'a mut ToolResultMetadata);-fn result_metadata_by_size(- items: &mut [ResponseItem],- prioritize_recent: bool,-) -> Vec<ResultMetadataEntry<'_>> {+fn result_metadata_by_size(items: &mut [ResponseItem]) -> Vec<ResultMetadataEntry<'_>> {let mut result_metadata = Vec::new();for (item_index, item) in items.iter_mut().enumerate() {if let Some(metadata) = item.internal_chat_message_metadata_passthrough_mut().and_then(Option::as_mut){- // The retained-history entry point has already reversed the items. Break size ties- // by evicting older outputs, while keeping the original call order within an output.- let eviction_order = if prioritize_recent {- usize::MAX - item_index- } else {- item_index- };for (call_index, call) in metadata.executed_tool_calls.iter_mut()@@ -252,7 +187,7 @@ fn result_metadata_by_size(.map_or(usize::MAX, |value| value.len());result_metadata.push((bytes,- eviction_order,+ item_index,call_index,&mut call.tool_result_metadata,));@@ -269,12 +204,10 @@ fn result_metadata_by_size(fn shed_generic_result_metadata(items: &mut [ResponseItem],max_metadata_bytes: usize,- prioritize_recent: bool,- whole_message: bool,mut total_metadata_bytes: usize,) -> usize {// Shed the largest values first so one large result does not discard unrelated small results.- let mut result_metadata = result_metadata_by_size(items, prioritize_recent);+ let mut result_metadata = result_metadata_by_size(items);for (bytes, _, _, metadata) in &mut result_metadata {if total_metadata_bytes <= max_metadata_bytes {break;@@ -294,19 +227,17 @@ fn shed_generic_result_metadata(}// Tiny generic values and markers can be cheaper than replacing them with a// new marker. Remove their complete fields before sacrificing resource evidence.- if whole_message {- for (bytes, _, _, metadata) in &mut result_metadata {- if total_metadata_bytes <= max_metadata_bytes {- break;- }- if metadata.retain_resource_access() {- continue;- }- **metadata = ToolResultMetadata::default();- total_metadata_bytes = total_metadata_bytes- .saturating_sub(bytes.saturating_add(b",\"tool_result_metadata\":".len()));- *bytes = 0;+ for (bytes, _, _, metadata) in &mut result_metadata {+ if total_metadata_bytes <= max_metadata_bytes {+ break;+ }+ if metadata.retain_resource_access() {+ continue;}+ **metadata = ToolResultMetadata::default();+ total_metadata_bytes = total_metadata_bytes+ .saturating_sub(bytes.saturating_add(b",\"tool_result_metadata\":".len()));+ *bytes = 0;}total_metadata_bytes}@@ -314,11 +245,9 @@ fn shed_generic_result_metadata(fn shed_remaining_result_metadata(items: &mut [ResponseItem],max_metadata_bytes: usize,- prioritize_recent: bool,- whole_message: bool,mut total_metadata_bytes: usize,) {- let mut result_metadata = result_metadata_by_size(items, prioritize_recent);+ let mut result_metadata = result_metadata_by_size(items);// Resource evidence is optional too; it must not displace the call inventory.for (bytes, _, _, metadata) in &mut result_metadata {if total_metadata_bytes <= max_metadata_bytes {@@ -333,9 +262,8 @@ fn shed_remaining_result_metadata(// Use the updated sizes: markers should be removed before smaller provider metadata.result_metadata.sort_by_key(|(bytes, order, call_index, metadata)| {(- whole_message && !metadata.is_omitted_due_to_size_limit(),- std::cmp::Reverse(*bytes),!metadata.is_omitted_due_to_size_limit(),+ std::cmp::Reverse(*bytes),*order,*call_index,)@@ -354,11 +282,7 @@ fn shed_remaining_result_metadata(}}-fn shed_result_sources(- items: &mut [ResponseItem],- max_metadata_bytes: usize,- whole_message: bool,-) -> usize {+fn shed_result_sources(items: &mut [ResponseItem], max_metadata_bytes: usize) -> usize {// Source evidence is optional; dropping it must not discard calls or their completion proof.let mut overage_bytes = metadata_bytes(items).saturating_sub(max_metadata_bytes);for item in items.iter_mut() {@@ -367,7 +291,7 @@ fn shed_result_sources(.and_then(Option::as_mut){for call in metadata.executed_tool_calls.iter_mut().flatten() {- if whole_message && overage_bytes == 0 {+ if overage_bytes == 0 {break;}if let Some(sources) = call.tool_result_sources.take() {@@ -439,7 +363,6 @@ fn truncate_call_arguments_to_fit(fn distribute_remaining_budget(items: &mut [ResponseItem],max_metadata_bytes: usize,- prioritize_recent: bool,damaged_cells: &mut HashSet<String>,) {let mut remaining_items = items@@ -452,11 +375,7 @@ fn distribute_remaining_budget(if item_bytes == 0 {continue;}- let item_budget = if prioritize_recent {- remaining_bytes- } else {- remaining_bytes / remaining_items- };+ let item_budget = remaining_bytes / remaining_items;if item_bytes > item_budget {// Remember the cell before a too-small share removes its metadata entirely.damaged_cells.extend(diff --git a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs b/codex-rs/protocol/src/models/executed_tool_calls_tests.rsindex 9195a693af..422db7f82e 100644--- a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs@@ -88,253 +88,20 @@ fn result_metadata_comparison_tracks_raw_values_and_call_bindings() {}#[test]-fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {- let metadata_bytes = |items: &[ResponseItem]| -> Result<usize> {- items.iter().try_fold(0_usize, |bytes, item| {- let with_metadata = serde_json::to_vec(item)?.len();- let mut without_metadata = item.clone();- without_metadata.clear_executed_tool_calls();- let without_metadata = serde_json::to_vec(&without_metadata)?.len();- Ok(bytes + with_metadata.saturating_sub(without_metadata))- })- };-- for with_turn_id in [true, false] {- let mut items = (0..4_000)- .map(|index| {- let mut item = output(&index.to_string());- *item- .internal_chat_message_metadata_passthrough_mut()- .unwrap() = with_turn_id.then(|| passthrough_metadata("turn-1"));- item.append_executed_tool_calls(vec![ExecutedToolCall::new(- String::new(),- serde_json::Value::Null,- )]);- item.set_tool_call_cell_id(&format!("cell-\"\\{}", "x".repeat(512)));- item.mark_tool_calls_complete();- item- })- .collect::<Vec<_>>();-- assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- bound_executed_tool_calls_for_prompt(&mut items);- assert!(metadata_bytes(&items)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- for metadata in items- .iter()- .filter_map(ResponseItem::executed_tool_call_metadata)- {- assert_eq!(metadata.tool_calls_complete, None);- }-- let calls = items- .iter()- .filter_map(ResponseItem::executed_tool_call_metadata)- .filter_map(|metadata| metadata.executed_tool_calls.as_ref())- .flatten()- .collect::<Vec<_>>();- // Shares smaller than a local marker omit that output; surviving calls stay unchanged.- assert!(!calls.is_empty() && calls.len() < 4_000);- assert!(calls.iter().all(|call| {- **call == ExecutedToolCall::new(String::new(), serde_json::Value::Null)- }));-- let bounded_items = items.clone();- bound_executed_tool_calls_for_prompt(&mut items);- assert_eq!(items, bounded_items);-- let oversized_names =- ["\0", "é"].map(|name| name.repeat(MAX_EXECUTED_TOOL_CALL_METADATA_BYTES));- let mut oversized_items = oversized_names- .iter()- .enumerate()- .map(|(index, name)| {- let mut item = output(&index.to_string());- *item- .internal_chat_message_metadata_passthrough_mut()- .unwrap() = with_turn_id.then(|| passthrough_metadata("turn-1"));- item.append_executed_tool_calls(vec![ExecutedToolCall::new(- name.clone(),- serde_json::Value::Null,- )]);- item.set_tool_call_cell_id("cell-\"\\");- item- })- .collect::<Vec<_>>();-- bound_executed_tool_calls_for_prompt(&mut oversized_items);- assert!(metadata_bytes(&oversized_items)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- let calls = oversized_items- .iter()- .filter_map(ResponseItem::executed_tool_call_metadata)- .filter_map(|metadata| metadata.executed_tool_calls.as_ref())- .flatten()- .collect::<Vec<_>>();- assert_eq!(calls.len(), 2);- for ((item, call), oversized_name) in- oversized_items.iter().zip(calls).zip(&oversized_names)- {- assert_eq!(- item.executed_tool_call_metadata()- .unwrap()- .cell_id- .as_deref(),- Some("cell-\"\\"),- );- assert!(call.name.len() < oversized_name.len());- assert!(oversized_name.starts_with(&call.name));- let truncation = call.truncation().expect("trusted omission marker");- assert_eq!(truncation.omitted_calls, None);- assert_eq!(truncation.original_name_bytes, Some(oversized_name.len()));- assert_eq!(- serde_json::to_value(&call.arguments)?["_codex_executed_tool_call_truncated"]["original_name_bytes"],- serde_json::json!(oversized_name.len()),- );- }-- let bounded_items = oversized_items.clone();- bound_executed_tool_calls_for_prompt(&mut oversized_items);- assert_eq!(oversized_items, bounded_items);- }-- let arguments = serde_json::json!({ "payload": "x".repeat(7 * 1024) });- let argument_bytes = serde_json::to_vec(&arguments)?.len();- assert!(argument_bytes < MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);- let call_count = MAX_EXECUTED_TOOL_CALL_METADATA_BYTES / argument_bytes + 1;- assert!(call_count * argument_bytes > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- let mut items = ["A", "wait-A", "B"].map(|call_id| {- let mut item = output(call_id);- item.mark_tool_calls_complete();- item- });- for item in &mut items[..2] {- item.set_tool_call_cell_id("cell-A");- }- let calls = vec![ExecutedToolCall::new("test_tool".to_string(), arguments); call_count];- items[0].append_executed_tool_calls(calls.clone());- items[2].append_executed_tool_calls(vec![ExecutedToolCall::new(- "test_tool".to_string(),- serde_json::json!({}),- )]);- assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- for bound in [- bound_executed_tool_calls_for_prompt,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- ] {- let mut bounded = items.clone();- bound(&mut bounded);- assert!(metadata_bytes(&bounded)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- assert_eq!(bounded[2], items[2]);- let metadata = bounded[0].executed_tool_call_metadata().unwrap();- assert_eq!(metadata.tool_calls_complete, None);- let recorded = metadata.executed_tool_calls.as_ref().unwrap();- assert_eq!(recorded.len(), 1);- assert_eq!(recorded[0].name, "test_tool");- let truncation = recorded[0].truncation().unwrap();- assert_eq!(truncation.original_bytes, argument_bytes);- assert_eq!(truncation.omitted_calls, Some(call_count - 1));- assert_eq!(- bounded[1]- .executed_tool_call_metadata()- .unwrap()- .tool_calls_complete,- None,- );- bounded[0].append_executed_tool_calls(calls.clone());- assert!(metadata_bytes(&bounded)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- bound(&mut bounded);- assert!(metadata_bytes(&bounded)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- assert_eq!(bounded[2], items[2]);- assert_eq!(- first_executed_tool_call(&mut bounded[0])- .unwrap()- .truncation()- .unwrap()- .omitted_calls,- Some(2 * call_count - 1),- );- }-- let mut items = ["exec", "wait"].map(|call_id| {- let mut item = output(call_id);- item.set_tool_call_cell_id("cell-\"\\");- item- });- items[0].append_executed_tool_calls(vec![- ExecutedToolCall::new(- "test_tool".to_string(),- serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - 256) }),- );- 16- ]);- items[1].mark_tool_calls_complete();- // Leave room for calls, but not their sources, without exceeding the argument limit.- let padding_bytes = MAX_EXECUTED_TOOL_CALL_METADATA_BYTES - metadata_bytes(&items)? - 1024;- let calls = items[0]- .ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap();- let call_count = calls.len();- for (index, call) in calls.iter_mut().enumerate() {- call.name.push_str(- &"x".repeat(- padding_bytes / call_count + usize::from(index < padding_bytes % call_count),- ),- );- }- let expected = items.clone();- assert!(- first_executed_tool_call(&mut items[0])- .expect("recorded call should exist")- .set_tool_result_sources(ToolResultSources::new(- (0..MAX_TOOL_RESULT_SOURCES)- .map(|index| ToolResultSource {- r#type: "document".to_string(),- id: format!(- "R{index:0width$}",- width = MAX_TOOL_RESULT_SOURCE_FIELD_BYTES - 1- ),- })- .collect(),- ))- );- assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- bound_executed_tool_calls_for_prompt(&mut items);- assert_eq!(items, expected);-- // Empty waits can carry only the marker; its bytes still count toward the budget.+fn metadata_byte_count_matches_serialized_fields() -> Result<()> {for metadata in [None, Some(passthrough_metadata("turn-1"))] {let mut item = output("wait");*item.internal_chat_message_metadata_passthrough_mut().unwrap() = metadata;- let without_marker = item.clone();- item.set_tool_call_cell_id(&format!("cell-\"\\{}", "x".repeat(256)));+ let without_calls = item.clone();+ item.set_tool_call_cell_id("cell");item.mark_tool_calls_complete();assert_eq!(- metadata_bytes(std::slice::from_ref(&item))?,executed_tool_call_metadata_bytes(&item),+ serde_json::to_vec(&item)?.len() - serde_json::to_vec(&without_calls)?.len(),);- let mut items = vec![item; 8_000];- assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- bound_executed_tool_calls_for_prompt_prioritizing_recent(&mut items);- assert!(metadata_bytes(&items)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- let retained = items- .iter()- .filter(|item| executed_tool_call_metadata_bytes(item) > 0)- .count();- assert!(retained > 0 && retained < 8_000);- for item in &mut items {- assert!(- item.executed_tool_call_metadata()- .is_none_or(|metadata| metadata.tool_calls_complete.is_none())- );- item.clear_executed_tool_calls();- }- assert_eq!(items, vec![without_marker; 8_000]);}-Ok(())}@@ -365,7 +132,7 @@ fn model_arguments_cannot_forge_executed_tool_call_truncation() -> Result<()> {forged_marker.clone(),)]);- bound_executed_tool_calls_for_prompt(std::slice::from_mut(&mut item));+ normalize_executed_tool_call_arguments(std::slice::from_mut(&mut item));let call = item.executed_tool_call_metadata().and_then(|metadata| metadata.executed_tool_calls.as_ref())@@ -410,7 +177,7 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {let mut item = output("call-1");item.set_tool_call_cell_id("cell-1");item.mark_tool_calls_complete();- bound_executed_tool_calls_for_prompt(std::slice::from_mut(&mut item));+ normalize_executed_tool_call_arguments(std::slice::from_mut(&mut item));assert_eq!(serde_json::to_value(&item)?["internal_chat_message_metadata_passthrough"],serde_json::json!({@@ -421,15 +188,21 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {item.clear_executed_tool_calls();assert!(item.executed_tool_call_metadata().is_none());- for call in [- ExecutedToolCall::new(- "test_tool".to_string(),- serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES + 1) }),+ for (call, newly_truncated) in [+ (+ ExecutedToolCall::new(+ "test_tool".to_string(),+ serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES + 1) }),+ ),+ true,),- ExecutedToolCall::truncated(- "test_tool".to_string(),- /*original_bytes*/ 9_000,- /*max_bytes*/ 0,+ (+ ExecutedToolCall::truncated(+ "test_tool".to_string(),+ /*original_bytes*/ 9_000,+ /*max_bytes*/ 0,+ ),+ false,),] {for same_cell in [false, true] {@@ -441,7 +214,12 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {}item.mark_tool_calls_complete();}- bound_executed_tool_calls_for_prompt(&mut items);+ let changed_cells = normalize_executed_tool_call_arguments(&mut items);+ assert_eq!(+ changed_cells.contains("cell-1"),+ same_cell && newly_truncated+ );+ assert!(normalize_executed_tool_call_arguments(&mut items).is_empty());assert_eq!(items.map(|item| item.executed_tool_call_metadata()@@ -817,77 +595,9 @@ fn message_budget_preserves_names_and_turn_metadata_and_invalidates_shared_cell_}}-#[test]-fn raw_result_metadata_is_shed_before_sources_calls_or_completion() -> Result<()> {- // Keep each result below its capture limit while filling the larger request budget.- let name = format!(- "test_tool{}",- "x".repeat(MAX_EXECUTED_TOOL_CALL_METADATA_BYTES / 8 - 16 * 1024)- );- let mut call = ExecutedToolCall::new(name, serde_json::json!({}));- call.set_tool_result_sources(ToolResultSources::new(vec![ToolResultSource {- r#type: "test_resource".to_string(),- id: "R1".to_string(),- }]));- let mut items = [- "first",- "second",- "third",- "fourth",- "fifth",- "sixth",- "seventh",- "without-metadata",- ]- .map(|call_id| {- let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {- call_id: call_id.to_string(),- output: FunctionCallOutputPayload::from_text("unchanged output".to_string()),- });- item.append_executed_tool_calls(vec![call.clone()]);- item.set_tool_call_cell_id(call_id);- item.mark_tool_calls_complete();- item- });- let metadata = ToolResultMetadata::new(&serde_json::json!({ "large": "x".repeat(20_000) }));- for item in &mut items[..7] {- first_executed_tool_call(item)- .unwrap()- .set_tool_result_metadata(metadata.clone());- }- let original_bytes = items- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>();- let mut expected = items.clone();- first_executed_tool_call(&mut expected[0])- .unwrap()- .set_tool_result_metadata(ToolResultMetadata::omitted_due_to_size_limit(- original_bytes - MAX_EXECUTED_TOOL_CALL_METADATA_BYTES,- ));- assert!(original_bytes > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- for bound in [- bound_executed_tool_calls_for_prompt,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- ] {- let mut bounded = items.clone();- bound(&mut bounded);- assert_eq!(bounded, expected);- assert!(- bounded- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES- );- bound(&mut bounded);- assert_eq!(bounded, expected);- }- Ok(())-}-#[test]fn result_metadata_shedding_keeps_smaller_results_within_one_output() {+ let budget = 2 * 1024 * 1024;let resource_only = serde_json::json!({"openai/resource_access": { "resource_coverage": "complete", "resources": [] },});@@ -928,7 +638,7 @@ fn result_metadata_shedding_keeps_smaller_results_within_one_output() {serde_json::json!({ "padding": "x".repeat(17_000) });6]);- let name_padding = (MAX_EXECUTED_TOOL_CALL_METADATA_BYTES - 128 * 1024) / metadata.len();+ let name_padding = (budget - 128 * 1024) / metadata.len();let mut item = output("exec");item.append_executed_tool_calls(metadata@@ -950,10 +660,10 @@ fn result_metadata_shedding_keeps_smaller_results_within_one_output() {);item.set_tool_call_cell_id("exec");item.mark_tool_calls_complete();- assert!(executed_tool_call_metadata_bytes(&item) > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);+ assert!(executed_tool_call_metadata_bytes(&item) > budget);let replacement = replacement.unwrap_or_else(|| {ToolResultMetadata::omitted_due_to_size_limit(- executed_tool_call_metadata_bytes(&item) - MAX_EXECUTED_TOOL_CALL_METADATA_BYTES,+ executed_tool_call_metadata_bytes(&item) - budget,)});let mut expected = item.clone();@@ -964,162 +674,11 @@ fn result_metadata_shedding_keeps_smaller_results_within_one_output() {.as_mut().unwrap()[reduced_index].set_tool_result_metadata(replacement);- for bound in [- bound_executed_tool_calls_for_prompt,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- |items: &mut [ResponseItem]| {- bound_executed_tool_calls_for_message(items, MAX_EXECUTED_TOOL_CALL_METADATA_BYTES)- },- ] {- let mut bounded = item.clone();- bound(std::slice::from_mut(&mut bounded));- assert_eq!(bounded, expected);- assert!(- executed_tool_call_metadata_bytes(&bounded)- <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES- );- bound(std::slice::from_mut(&mut bounded));- assert_eq!(bounded, expected);- }- }-}--#[test]-fn result_metadata_shedding_removes_only_markers_needed_to_fit() {- let mut item = output("exec");- let mut call = ExecutedToolCall::new("test_tool".to_string(), serde_json::json!({}));- call.set_tool_result_sources(ToolResultSources::new(vec![ToolResultSource {- r#type: "test_resource".to_string(),- id: "R1".to_string(),- }]));- let mut calls = vec![call; 20];- let omitted = ToolResultMetadata::omitted_due_to_size_limit(/*overage_bytes*/ 1);- let marker_bytes = serde_json::to_vec(&omitted).unwrap().len();- // A real object tied with a marker must survive even though it is older.- let equal_sized = ToolResultMetadata::new(&serde_json::json!({- "value": "x".repeat(marker_bytes - r#"{"value":""}"#.len()),- }));- assert_eq!(- serde_json::to_vec(&equal_sized).unwrap().len(),- marker_bytes- );- calls[0].set_tool_result_metadata(equal_sized);- for index in [1, 3] {- calls[index].set_tool_result_metadata(omitted.clone());- }- calls[2].set_tool_result_metadata(ToolResultMetadata::new(&serde_json::json!({})));- item.append_executed_tool_calls(calls);- item.set_tool_call_cell_id("exec");- item.mark_tool_calls_complete();- let remaining_bytes =- MAX_EXECUTED_TOOL_CALL_METADATA_BYTES + 1 - executed_tool_call_metadata_bytes(&item);- let calls = item- .ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap();- let call_count = calls.len();- for (index, call) in calls.iter_mut().enumerate() {- // Pad names so the per-argument limit cannot preempt result-metadata shedding.- call.name.push_str(&"x".repeat(- remaining_bytes / call_count + usize::from(index < remaining_bytes % call_count),- ));- }- assert_eq!(- executed_tool_call_metadata_bytes(&item),- MAX_EXECUTED_TOOL_CALL_METADATA_BYTES + 1- );- let mut expected = item.clone();- expected- .ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap()[1]- .set_tool_result_metadata(ToolResultMetadata::default());- let tied_markers = item.clone();- // The new marker has a larger overage value and therefore more bytes. Remove- // that marker first, while tied smaller markers still precede provider data.- item.ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap()[3]- .set_tool_result_metadata(ToolResultMetadata::new(&serde_json::json!({- "large": "x".repeat(4 * 1024),- })));- let mut larger_marker_expected = item.clone();- larger_marker_expected- .ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap()[3]- .set_tool_result_metadata(ToolResultMetadata::default());- for (item, expected) in [(tied_markers, expected), (item, larger_marker_expected)] {- for bound in [- bound_executed_tool_calls_for_prompt,- bound_executed_tool_calls_for_prompt_prioritizing_recent,- ] {- let mut bounded = item.clone();- bound(std::slice::from_mut(&mut bounded));- assert_eq!(bounded, expected);- assert!(- executed_tool_call_metadata_bytes(&bounded)- <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES- );- bound(std::slice::from_mut(&mut bounded));- assert_eq!(bounded, expected);- }- }-}--#[test]-fn result_metadata_markers_do_not_displace_existing_evidence() {- let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {- call_id: "exec".to_string(),- output: FunctionCallOutputPayload::from_text("unchanged output".to_string()),- });- let mut call = ExecutedToolCall::new("test_tool".to_string(), serde_json::json!({}));- call.set_tool_result_sources(ToolResultSources::new(vec![ToolResultSource {- r#type: "test_resource".to_string(),- id: "R1".to_string(),- }]));- item.append_executed_tool_calls(vec![call; 20]);- item.set_tool_call_cell_id("exec");- item.mark_tool_calls_complete();- let remaining_bytes =- MAX_EXECUTED_TOOL_CALL_METADATA_BYTES - executed_tool_call_metadata_bytes(&item);- let calls = item- .ensure_tool_call_metadata()- .unwrap()- .executed_tool_calls- .as_mut()- .unwrap();- let call_count = calls.len();- for (index, call) in calls.iter_mut().enumerate() {- // Fill the budget exactly without increasing arguments past their individual limit.- call.name.push_str(&"x".repeat(- remaining_bytes / call_count + usize::from(index < remaining_bytes % call_count),- ));- }- assert_eq!(- executed_tool_call_metadata_bytes(&item),- MAX_EXECUTED_TOOL_CALL_METADATA_BYTES- );- let expected = item.clone();- for metadata in [- serde_json::json!({ "too-large": "x".repeat(32 * 1024) }),- serde_json::json!({- "openai/resource_access": { "resource_coverage": "complete", "resources": [] },- }),- ] {- let mut item = expected.clone();- first_executed_tool_call(&mut item)- .unwrap()- .set_tool_result_metadata(ToolResultMetadata::new(&metadata));- bound_executed_tool_calls_for_prompt(std::slice::from_mut(&mut item));- assert_eq!(item, expected);+ let mut bounded = item.clone();+ bound_executed_tool_calls_for_message(std::slice::from_mut(&mut bounded), budget);+ assert_eq!(bounded, expected);+ assert!(executed_tool_call_metadata_bytes(&bounded) <= budget);+ bound_executed_tool_calls_for_message(std::slice::from_mut(&mut bounded), budget);+ assert_eq!(bounded, expected);}}