Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve large arguments in executed tool call metadata (#52268)

ningyi-oai515c291d875e
diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rs
index 6ca54d44a3..853c88a972 100644
--- a/codex-rs/core/src/tools/executed_tool_calls.rs
+++ b/codex-rs/core/src/tools/executed_tool_calls.rs
@@ -28,7 +28,7 @@ use codex_protocol::models::ExecutedToolCallArguments;
use codex_protocol::models::ResponseItem;
use codex_protocol::models::ToolResultMetadata;
use codex_protocol::models::executed_tool_call_metadata_bytes;
-use codex_protocol::models::normalize_executed_tool_call_arguments;
+use codex_protocol::models::normalize_executed_tool_call_completeness;
use codex_protocol::openai_models::ToolMode;
use indexmap::IndexMap;
use serde_json::Value as JsonValue;
@@ -46,8 +46,6 @@ mod seen_ids;
use seen_ids::SeenIds;
-const MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES: usize = 8 * 1024;
-const MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT: usize = 32 * 1024;
const MAX_PENDING_EXECUTED_TOOL_CALLS: usize = 256;
// Limits new Direct metadata retained in history and the append-only rollout
// during one recorder lifetime. A new process cannot recover the exact prior
@@ -150,7 +148,6 @@ enum CellCompletion {
#[derive(Default)]
struct RecordedCell {
pending_calls: IndexMap<String, ExecutedToolCall>,
- pending_full_argument_bytes: usize,
completion: CellCompletion,
originating_call_id: Option<String>,
truncated_metadata_binding_valid: bool,
@@ -365,17 +362,7 @@ impl ExecutedToolCalls {
return None;
}
let permit = self.reserve_direct_call()?;
- let (mut recorded, _) = recorded_call(call);
- let argument_bytes = serialized_json_bytes(recorded.arguments()).unwrap_or(usize::MAX);
- if matches!(recorded.arguments(), ExecutedToolCallArguments::Raw(_))
- && argument_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES
- {
- recorded = ExecutedToolCall::truncated(
- recorded.name,
- argument_bytes,
- MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,
- );
- }
+ let (recorded, _) = recorded_call(call);
Some((recorded, permit))
}
@@ -561,19 +548,10 @@ impl ExecutedToolCalls {
if !unique_nested_id || duplicate_call_id {
cell.truncated_metadata_binding_valid = false;
}
- let max_bytes = MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES.min(
- MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT
- .saturating_sub(cell.pending_full_argument_bytes),
- );
let call = if at_pending_call_limit {
ExecutedToolCall::truncated(call.name, original_bytes, /*max_bytes*/ 0)
- } else if original_bytes <= max_bytes {
- cell.pending_full_argument_bytes = cell
- .pending_full_argument_bytes
- .saturating_add(original_bytes);
- call
} else {
- ExecutedToolCall::truncated(call.name, original_bytes, max_bytes)
+ call
};
let truncated = matches!(
call.arguments(),
@@ -748,20 +726,16 @@ fn recorded_call(call: &ToolCall) -> (ExecutedToolCall, usize) {
}
};
let name = codex_tools::code_mode_name_for_tool_name(&call.tool_name);
- let recorded_call = if original_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES {
- ExecutedToolCall::truncated(name, original_bytes, MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES)
- } else {
- let arguments = match &call.payload {
- ToolPayload::Function { arguments } => serde_json::from_str(arguments)
- .unwrap_or_else(|_| JsonValue::String(arguments.clone())),
- ToolPayload::Custom { input } => JsonValue::String(input.clone()),
- ToolPayload::ToolSearch { arguments } => {
- serde_json::to_value(arguments).unwrap_or_default()
- }
- };
- ExecutedToolCall::new(name, arguments)
+ let arguments = match &call.payload {
+ ToolPayload::Function { arguments } => {
+ serde_json::from_str(arguments).unwrap_or_else(|_| JsonValue::String(arguments.clone()))
+ }
+ ToolPayload::Custom { input } => JsonValue::String(input.clone()),
+ ToolPayload::ToolSearch { arguments } => {
+ serde_json::to_value(arguments).unwrap_or_default()
+ }
};
- (recorded_call, original_bytes)
+ (ExecutedToolCall::new(name, arguments), original_bytes)
}
fn input_call_id(item: &ResponseItem) -> Option<&str> {
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 346bc01ff7..01d0056b59 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
@@ -57,7 +57,7 @@ impl ExecutedToolCalls {
// Argument truncation preserves inventory completeness; omitted calls or
// names still invalidate completion across the cell's outputs.
- normalize_executed_tool_call_arguments(items);
+ normalize_executed_tool_call_completeness(items);
}
fn attach_pending_to_prompt_with_state(
@@ -258,7 +258,6 @@ impl ExecutedToolCalls {
}
calls.push(call);
}
- cell.pending_full_argument_bytes = 0;
complete = cell.completion == CellCompletion::Complete
&& (state.can_prove_wait_completion
|| matches!(item, ResponseItem::CustomToolCallOutput { .. }));
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 e168c9a660..1c504bf872 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
@@ -886,11 +886,11 @@ fn tool_call_completeness_survives_waits_without_changing_deltas() {
if index < 2 {
// Identical calls are distinct submissions; truncation stays sticky across waits.
let original_bytes = if truncated && index == 1 { 9_000 } else { 2 };
- let call = if original_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES {
+ let call = if truncated && index == 1 {
ExecutedToolCall::truncated(
"nested_tool".to_string(),
original_bytes,
- MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,
+ /*max_bytes*/ 8_192,
)
} else {
ExecutedToolCall::new("nested_tool".to_string(), json!({}))
@@ -1156,40 +1156,33 @@ fn completeness_rejects_direct_id_collision_and_late_calls() {
}
#[test]
-fn newly_normalized_arguments_preserve_later_wait_completeness() {
+fn large_wrapped_arguments_preserve_later_wait_completeness() {
let recorder = new_recorder(InitialHistory::New);
let cell = CellId::new("active-cell".to_string());
recorder.start_cell(&cell, "exec");
let arguments = json!({
"_codex_executed_tool_call_truncated": true,
- "padding": "x".repeat(8_120),
- })
- .to_string();
+ "padding": "x".repeat(40 * 1024),
+ });
let (call, original_bytes) = recorded_call(&ToolCall {
tool_name: codex_tools::ToolName::plain("nested_tool"),
call_id: "nested".to_string(),
- payload: ToolPayload::Function { arguments },
+ payload: ToolPayload::Function {
+ arguments: arguments.to_string(),
+ },
encrypted_function_args: None,
});
- 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!(
+ assert_eq!(
initial[1]
.executed_tool_call_metadata()
.unwrap()
.executed_tool_calls
.as_ref()
- .unwrap()
- .iter()
- .any(|call| matches!(
- call.arguments(),
- ExecutedToolCallArguments::Truncated { .. }
- ))
+ .unwrap(),
+ &vec![ExecutedToolCall::new("nested_tool".to_string(), arguments)],
);
recorder.register_cell(&cell, "wait");
recorder.finish_cell_recording(&cell);
@@ -1612,13 +1605,12 @@ fn late_truncated_metadata_preserves_large_result_on_retry() {
}
#[test]
-fn late_truncated_metadata_is_not_reused_after_budget_changes_calls() {
+fn late_truncated_metadata_with_wrapped_arguments_rejects_ambiguous_outputs() {
let recorder = new_recorder(InitialHistory::New);
let cell = CellId::new("late-truncated-cell".to_string());
recorder.start_cell(&cell, "exec");
record_truncated_call(&recorder, &cell, "nested");
- // The reserved key requires a wrapper in recorded arguments. The wrapper can
- // put an otherwise accepted function argument over the later prompt limit.
+ // The reserved key requires a wrapper in recorded arguments.
let arguments = json!({
"_codex_executed_tool_call_truncated": true,
"padding": "x".repeat(8_120),
@@ -1630,11 +1622,6 @@ fn late_truncated_metadata_is_not_reused_after_budget_changes_calls() {
payload: ToolPayload::Function { arguments },
encrypted_function_args: None,
});
- assert!(original_bytes <= MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);
- assert!(
- serialized_json_bytes(wrapped_call.arguments()).unwrap()
- > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES
- );
recorder.record_nested_tool_call(
cell.clone(),
"other".to_string(),
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 bda3cca798..304375bbb8 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
@@ -245,7 +245,7 @@ async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
}
#[tokio::test]
-async fn direct_budget_counts_the_encoded_argument_before_it_enters_history() {
+async fn direct_recording_preserves_encoded_arguments_in_history() {
let (_, turn) = crate::session::tests::make_session_and_context().await;
let step = StepContext::for_test(Arc::new(turn));
let mut features = Features::default();
@@ -253,13 +253,12 @@ async fn direct_budget_counts_the_encoded_argument_before_it_enters_history() {
let recorder = ExecutedToolCalls::new(&features, &InitialHistory::New);
let invalid_json = "\"".repeat(5_000);
let wire_bytes = serialized_json_bytes(&JsonValue::String(invalid_json.clone())).unwrap();
- assert!(invalid_json.len() < MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);
- assert!(wire_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);
+ assert!(wire_bytes > 8 * 1024);
let call = ToolCall {
tool_name: codex_tools::ToolName::plain("test_tool"),
call_id: "direct".to_string(),
payload: ToolPayload::Function {
- arguments: invalid_json,
+ arguments: invalid_json.clone(),
},
encrypted_function_args: None,
};
@@ -273,10 +272,7 @@ async fn direct_budget_counts_the_encoded_argument_before_it_enters_history() {
assert_eq!(wire["output"], ordinary_output);
let metadata = &wire["internal_chat_message_metadata_passthrough"];
let arguments = &metadata["executed_tool_calls"][0]["arguments"];
- assert!(serialized_json_bytes(arguments).unwrap() < MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES);
- assert_eq!(
- arguments["_codex_executed_tool_call_truncated"]["original_bytes"],
- wire_bytes,
- );
+ assert_eq!(arguments, &JsonValue::String(invalid_json));
+ assert_eq!(serialized_json_bytes(arguments).unwrap(), wire_bytes);
assert_eq!(metadata["tool_calls_complete"], true);
}
diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs
index 40cd9bd5e5..b2371a0c9e 100644
--- a/codex-rs/core/tests/suite/code_mode.rs
+++ b/codex-rs/core/tests/suite/code_mode.rs
@@ -1548,7 +1548,7 @@ async fn code_mode_tool_call_completeness_is_private_and_opt_in(
let code = if oversized {
r#"
const args = { barrier: { id: "", participants: 1 } };
-args.barrier.id = "x".repeat(8192 - JSON.stringify(args).length);
+args.barrier.id = "x".repeat(9000 - JSON.stringify(args).length);
for (let index = 0; index < 17; index++) await tools.test_sync_tool(args);
text("done");
yield_control();
@@ -1577,12 +1577,17 @@ await new Promise(() => {});
let calls = serde_json::json!([{ "name": "test_sync_tool", "arguments": {} }]);
let complete = Value::Bool(true);
if oversized {
- assert!(
- metadata["executed_tool_calls"]
- .as_array()
- .is_some_and(|calls| calls.iter().any(|call| call["arguments"]
- .get("_codex_executed_tool_call_truncated")
- .is_some()))
+ let mut arguments = serde_json::json!({ "barrier": { "id": "", "participants": 1 } });
+ arguments["barrier"]["id"] =
+ serde_json::json!("x".repeat(9000 - arguments.to_string().len()));
+ assert_eq!(
+ metadata["executed_tool_calls"],
+ serde_json::json!(vec![
+ serde_json::json!({
+ "name": "test_sync_tool", "arguments": arguments,
+ });
+ 17
+ ]),
);
} else {
assert_eq!(
@@ -2976,7 +2981,7 @@ async fn code_mode_result_metadata_keeps_prepared_call_binding_across_runtime_re
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn code_mode_late_truncated_result_metadata_survives_waits() -> Result<()> {
+async fn code_mode_late_result_metadata_with_large_arguments_survives_waits() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
let metadata = serde_json::json!({
@@ -3028,7 +3033,7 @@ async fn code_mode_late_truncated_result_metadata_survives_waits() -> Result<()>
.context("first call did not reach the result gate")??;
// The call may be dispatched after the first yield. Wait while its result is held so
- // the request has already recorded the truncated call before accepting its metadata.
+ // the request has already recorded the call before accepting its metadata.
let held = responses::mount_function_call_agent_response(
&server,
"call-2",
@@ -3044,16 +3049,16 @@ async fn code_mode_late_truncated_result_metadata_survives_waits() -> Result<()>
let original_output = held_calls[0];
let original_id = original_output["call_id"].as_str().unwrap().to_string();
let original_type = original_output["type"].as_str().unwrap().to_string();
- let truncated =
+ let recorded =
&original_output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0];
assert!(
- truncated["name"]
+ recorded["name"]
.as_str()
.unwrap()
.ends_with(RESULT_METADATA_TOOL)
);
- assert!(truncated["arguments"]["_codex_executed_tool_call_truncated"].is_object());
- assert!(truncated.get("tool_result_metadata").is_none());
+ assert_eq!(recorded["arguments"], arguments);
+ assert!(recorded.get("tool_result_metadata").is_none());
release_tx.send(()).unwrap();
let resumed = responses::mount_function_call_agent_response(
@@ -3096,7 +3101,7 @@ async fn code_mode_late_truncated_result_metadata_survives_waits() -> Result<()>
let captured_calls =
&captured_output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"];
assert_eq!(captured_calls.as_array().unwrap().len(), 1);
- assert_eq!(captured_calls[0]["arguments"], truncated["arguments"]);
+ assert_eq!(captured_calls[0]["arguments"], recorded["arguments"]);
assert_eq!(captured_calls[0]["tool_result_metadata"], metadata);
assert_ne!(
captured_output["internal_chat_message_metadata_passthrough"]["tool_calls_complete"],
@@ -3124,7 +3129,7 @@ async fn code_mode_late_truncated_result_metadata_survives_waits() -> Result<()>
let original = terminal_request.call_output(&original_id, &original_type);
assert_eq!(
original["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["arguments"],
- truncated["arguments"]
+ recorded["arguments"]
);
assert!(
original["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]
@@ -3548,7 +3553,7 @@ text("pressure ready");"#,
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn code_mode_complete_call_survives_unrelated_truncation() -> Result<()> {
+async fn code_mode_complete_calls_preserve_large_arguments() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
@@ -3589,12 +3594,11 @@ async fn code_mode_complete_call_survives_unrelated_truncation() -> Result<()> {
let request = follow_up.single_request();
let overflow =
&request.custom_tool_call_output("call-1")["internal_chat_message_metadata_passthrough"];
- assert!(
- overflow["executed_tool_calls"]
- .as_array()
- .is_some_and(|calls| calls.iter().any(|call| call["arguments"]
- .get("_codex_executed_tool_call_truncated")
- .is_some()))
+ assert_eq!(
+ overflow["executed_tool_calls"],
+ serde_json::json!([{ "name": "test_sync_tool", "arguments": {
+ "barrier": { "id": "x".repeat(8192), "participants": 1 }
+ } }]),
);
assert_eq!(overflow["tool_calls_complete"], true);
@@ -9278,8 +9282,7 @@ async fn code_mode_argument_truncation_preserves_later_wait_completeness() -> Re
probe.codex.shutdown_and_wait().await?;
probe_server.shutdown().await;
- // One 7 KiB invocation stays under the recorder's per-output argument
- // budget. It pushes the yielded delta over the message budget only.
+ // One 7 KiB invocation pushes the yielded delta over the message budget.
let padding = "x".repeat(LIMIT - base_bytes - 4 * 1024);
let code = r#"
await tools.test_sync_tool({ barrier: { id: "x".repeat(7000), participants: 1 } });
diff --git a/codex-rs/core/tests/suite/direct_tool_metadata.rs b/codex-rs/core/tests/suite/direct_tool_metadata.rs
index 67285f14ac..68fc43e217 100644
--- a/codex-rs/core/tests/suite/direct_tool_metadata.rs
+++ b/codex-rs/core/tests/suite/direct_tool_metadata.rs
@@ -538,6 +538,8 @@ async fn direct_function_and_tool_search_mark_complete_attempts(
// These calls exceed the old request budget but stay below Direct's retained-history limit.
let budget_arguments =
json!({"plan": [{"step": "x".repeat(7 * 1024), "status": "in_progress"}]});
+ let oversized_arguments =
+ json!({"plan": [{"step": "x".repeat(9 * 1024), "status": "in_progress"}]});
let budget_arguments_json = budget_arguments.to_string();
assert!(budget_arguments_json.len() < 8 * 1024);
if budget_calls > 0 {
@@ -549,7 +551,7 @@ async fn direct_function_and_tool_search_mark_complete_attempts(
events.push(ev_function_call(
"plan-oversized",
"update_plan",
- &json!({"plan": [{"step": "x".repeat(9 * 1024), "status": "in_progress"}]}).to_string(),
+ &oversized_arguments.to_string(),
));
}
for index in 0..budget_calls {
@@ -625,12 +627,13 @@ async fn direct_function_and_tool_search_mark_complete_attempts(
assert_eq!(output["output"], json!("Plan updated"));
let metadata = tool_call_metadata(output);
metadata_bytes += serde_json::to_vec(&metadata)?.len();
- assert!(
- metadata["executed_tool_calls"][0]["arguments"]
- .get("_codex_executed_tool_call_truncated")
- .is_some()
+ assert_eq!(
+ metadata,
+ json!({
+ "executed_tool_calls": [{"name": "update_plan", "arguments": oversized_arguments}],
+ "tool_calls_complete": true,
+ }),
);
- assert_eq!(metadata["tool_calls_complete"], true);
}
for index in 0..budget_calls {
let output = request.function_call_output(&format!("plan-budget-{index}"));
diff --git a/codex-rs/core/tests/suite/tools.rs b/codex-rs/core/tests/suite/tools.rs
index cf663b0be4..e371db1e3f 100644
--- a/codex-rs/core/tests/suite/tools.rs
+++ b/codex-rs/core/tests/suite/tools.rs
@@ -527,12 +527,7 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
);
let expected_escaped_calls = json!([{
"name": format!("{namespace}__{tool_name}"),
- "arguments": {
- "_codex_executed_tool_call_truncated": {
- "original_bytes": serde_json::to_vec(&escaped_input)?.len(),
- "max_bytes": 8 * 1024,
- },
- },
+ "arguments": escaped_input,
}]);
assert_eq!(
tool_call_metadata(escaped_request.custom_tool_call_output(escaped_call_id)),
diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rs
index 58e20012d1..28b70155ad 100644
--- a/codex-rs/protocol/src/models.rs
+++ b/codex-rs/protocol/src/models.rs
@@ -50,7 +50,7 @@ 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::executed_tool_call_metadata_bytes;
-pub use executed_tool_calls::normalize_executed_tool_call_arguments;
+pub use executed_tool_calls::normalize_executed_tool_call_completeness;
pub use item_metadata::ContentItemKind;
pub use item_metadata::ContentItemMetadata;
pub use item_metadata::ContentItemNamespace;
diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rs
index 2a817a6a0e..95151c2694 100644
--- a/codex-rs/protocol/src/models/executed_tool_calls.rs
+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs
@@ -8,7 +8,6 @@ use ts_rs::TS;
use super::InternalChatMessageMetadataPassthrough;
use super::ResponseItem;
-const MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES: usize = 8 * 1024;
/// Maximum distinct result sources retained for one tool invocation.
const MAX_TOOL_RESULT_SOURCES: usize = 32;
/// Maximum UTF-8 bytes for each source's `type` and `id` separately, not the source list.
@@ -86,12 +85,10 @@ impl InternalChatMessageMetadataPassthrough {
}
}
-/// Bounds recorded arguments, preserving completion unless calls or tool names were lost.
-/// 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> {
+/// Clears completion across a cell when recorded calls or tool names were lost.
+/// Argument truncation preserves inventory completeness; arguments and outputs are unchanged.
+pub fn normalize_executed_tool_call_completeness(items: &mut [ResponseItem]) {
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()
@@ -99,33 +96,17 @@ pub fn normalize_executed_tool_call_arguments(items: &mut [ResponseItem]) -> Has
else {
continue;
};
- let mut inventory_lost = 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())
- .unwrap_or(usize::MAX);
- if call.truncation().is_none() && argument_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES
- {
- call.set_truncation(
- argument_bytes,
- MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,
- /*omitted_calls*/ None,
- );
- newly_truncated = true;
- }
- inventory_lost |= !call.has_complete_inventory();
- }
- if inventory_lost {
+ if metadata
+ .executed_tool_calls
+ .iter()
+ .flatten()
+ .any(|call| !call.has_complete_inventory())
+ {
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);
- newly_truncated_cells
}
/// Bounds optional observations to the space left in the actual outgoing message.
@@ -339,9 +320,7 @@ fn truncate_call_arguments_to_fit(
let truncated = ExecutedToolCallArguments::Truncated {
truncation: ExecutedToolCallTruncation {
original_bytes,
- max_bytes: original_bytes
- .saturating_sub(overage_bytes)
- .min(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES),
+ max_bytes: original_bytes.saturating_sub(overage_bytes),
omitted_calls: None,
original_name_bytes: None,
},
@@ -849,7 +828,7 @@ impl ResponseItem {
let omitted_calls = (represented_calls > 1).then_some(represented_calls - 1);
call.set_truncation_with_name(
original_bytes,
- max_call_bytes.min(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES),
+ max_call_bytes,
omitted_calls,
original_name_bytes,
);
@@ -862,7 +841,7 @@ impl ResponseItem {
let call = &mut calls[0];
call.set_truncation_with_name(
original_bytes,
- max_call_bytes.min(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES),
+ max_call_bytes,
omitted_calls,
Some(original_name_bytes.unwrap_or(call.name.len())),
);
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 311d6c2a3c..7ce7159974 100644
--- a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs
+++ b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs
@@ -132,7 +132,7 @@ fn model_arguments_cannot_forge_executed_tool_call_truncation() -> Result<()> {
forged_marker.clone(),
)]);
- normalize_executed_tool_call_arguments(std::slice::from_mut(&mut item));
+ normalize_executed_tool_call_completeness(std::slice::from_mut(&mut item));
let call = item
.executed_tool_call_metadata()
.and_then(|metadata| metadata.executed_tool_calls.as_ref())
@@ -177,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();
- normalize_executed_tool_call_arguments(std::slice::from_mut(&mut item));
+ normalize_executed_tool_call_completeness(std::slice::from_mut(&mut item));
assert_eq!(
serde_json::to_value(&item)?["internal_chat_message_metadata_passthrough"],
serde_json::json!({
@@ -188,21 +188,15 @@ 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, newly_truncated) in [
- (
- ExecutedToolCall::new(
- "test_tool".to_string(),
- serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES + 1) }),
- ),
- true,
+ for call in [
+ ExecutedToolCall::new(
+ "test_tool".to_string(),
+ serde_json::json!({ "payload": "x".repeat(9_000) }),
),
- (
- ExecutedToolCall::truncated(
- "test_tool".to_string(),
- /*original_bytes*/ 9_000,
- /*max_bytes*/ 0,
- ),
- false,
+ ExecutedToolCall::truncated(
+ "test_tool".to_string(),
+ /*original_bytes*/ 9_000,
+ /*max_bytes*/ 0,
),
] {
for same_cell in [false, true] {
@@ -214,12 +208,11 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {
}
item.mark_tool_calls_complete();
}
- 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());
+ let expected = items.clone();
+ normalize_executed_tool_call_completeness(&mut items);
+ assert_eq!(items, expected);
+ normalize_executed_tool_call_completeness(&mut items);
+ assert_eq!(items, expected);
assert_eq!(
items.map(|item| item
.executed_tool_call_metadata()
@@ -605,7 +598,7 @@ fn inventory_loss_still_clears_completeness() {
let mut item = output("call");
item.append_executed_tool_calls(vec![call]);
item.mark_tool_calls_complete();
- normalize_executed_tool_call_arguments(std::slice::from_mut(&mut item));
+ normalize_executed_tool_call_completeness(std::slice::from_mut(&mut item));
assert_eq!(
item.executed_tool_call_metadata()
.unwrap()