Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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_firs
recorder.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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!(
recorder
diff --git a/codex-rs/core/src/tools/metadata_metrics.rs b/codex-rs/core/src/tools/metadata_metrics.rs
index 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.rs
index 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.rs
index 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.rs
index 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_provi
recorded_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.rs
index 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.rs
index 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.rs
index 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);
}
}