Lightweight coding agent that runs in your terminal
Rust
Preserve tool result metadata more selectively under size limits (#47714)
ningyi-oaie7165c2dbb14
diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rsindex 4f809b0a1d..12c341b5a9 100644--- a/codex-rs/core/src/client_tests.rs+++ b/codex-rs/core/src/client_tests.rs@@ -610,6 +610,92 @@ fn responses_request_limits_internal_metadata_to_resolved_first_party_https_endpOk(())}+#[test]+fn responses_request_preserves_smaller_result_metadata_under_aggregate_budget() -> anyhow::Result<()>+{+ let result_metadata = [+ json!({ "payload": "l".repeat(31 * 1024) }),+ json!({ "payload": "m".repeat(20 * 1024) }),+ json!({ "payload": "m".repeat(20 * 1024) }),+ json!({ "payload": "m".repeat(20 * 1024) }),+ json!({ "payload": "m".repeat(20 * 1024) }),+ json!({ "payload": "m".repeat(20 * 1024) }),+ json!({ "status": "ok" }),+ ];+ let sizes = result_metadata+ .iter()+ .map(|metadata| serde_json::to_vec(metadata).unwrap().len())+ .collect::<Vec<_>>();+ assert!(sizes.iter().all(|bytes| *bytes < 32 * 1024));+ assert!(sizes.iter().sum::<usize>() > 128 * 1024);+ let mut history = Vec::new();+ for (index, metadata) in result_metadata.iter().enumerate() {+ let id = format!("tool-call-{index}");+ history.push(serde_json::from_value(json!({+ "type": "function_call", "call_id": id, "name": "test_tool",+ "arguments": json!({ "query": "keep" }).to_string(),+ }))?);+ let mut output = output_with_tool_result_metadata(ToolResultMetadata::new(metadata));+ let ResponseItem::FunctionCallOutput { call_id, .. } = &mut output else {+ unreachable!("helper returns a function call output");+ };+ *call_id = Some(id);+ history.push(output);+ }+ let original_history = serde_json::to_value(&history)?;+ let mut expected_input = original_history.clone();+ expected_input[1]["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]["tool_result_metadata"] =+ json!("omitted_due_to_size_limit");++ let mut features = codex_features::Features::default();+ features.enable(codex_features::Feature::ExecutedToolCallMetadata);+ let recorder =+ crate::tools::ExecutedToolCalls::new(&features, &codex_history::InitialHistory::New);+ let mut prompt = Prompt {+ input: history.clone(),+ ..Default::default()+ };+ // Follow the sampling path: budget the request copy before client serialization.+ recorder.attach_to_prompt(&mut prompt.input, &mut Default::default());+ let provider =+ ModelProviderInfo::create_openai_provider(Some("https://api.openai.com/v1".to_string()));+ let api_provider = provider.to_api_provider(/*auth_mode*/ None)?;+ let mut client = test_model_client(SessionSource::Cli);+ Arc::get_mut(&mut client.state)+ .expect("test client should have unique session state")+ .provider = create_model_provider(provider, /*auth_manager*/ None);+ let responses_metadata = test_responses_metadata_for_client(+ &client,+ /*turn_id*/ None,+ format!("{}:0", client.state.thread_id),+ /*parent_thread_id*/ None,+ TestCodexResponsesRequestKind::Turn,+ );+ let request = client.build_responses_request(+ &prompt,+ &test_model_info(),+ /*effort*/ None,+ codex_protocol::config_types::ReasoningSummary::None,+ /*service_tier*/ None,+ &responses_metadata,+ super::is_internal_metadata_destination(&api_provider),+ )?;+ let body = serde_json::to_value(&request)?;+ // Whole-input equality covers bindings, arguments, results, sources and completion too.+ assert_eq!(body["input"], expected_input);+ let mut without_metadata = body.clone();+ for item in without_metadata["input"].as_array_mut().unwrap() {+ item.as_object_mut()+ .unwrap()+ .remove("internal_chat_message_metadata_passthrough");+ }+ let metadata_bytes =+ serde_json::to_vec(&body)?.len() - serde_json::to_vec(&without_metadata)?.len();+ assert!(metadata_bytes <= 128 * 1024);+ assert_eq!(serde_json::to_value(&history)?, original_history);+ Ok(())+}+#[test]fn websocket_incremental_reuse_tracks_raw_result_metadata() -> anyhow::Result<()> {let provider =diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rsindex 088d1234cf..bbefb411b8 100644--- a/codex-rs/core/src/compact_tests.rs+++ b/codex-rs/core/src/compact_tests.rs@@ -48,7 +48,7 @@ async fn local_compaction_respects_tool_metadata_state(.await;let mut items = vec![user_message("Update the plan")];- for index in 0..5 {+ for index in 0..20 {let call_id = format!("direct-{index}");let arguments = json!({"plan": [{"step": "x".repeat(7 * 1024), "status": "completed"}]});assert!(serde_json::to_vec(&arguments)?.len() < 8 * 1024);@@ -129,7 +129,7 @@ async fn local_compaction_respects_tool_metadata_state(_ => None,}).collect::<serde_json::Result<Vec<_>>>()?;- assert_eq!(outputs.len(), 5);+ assert_eq!(outputs.len(), 20);let metadata_bytes: usize = outputs.iter().map(|item| {@@ -140,7 +140,7 @@ async fn local_compaction_respects_tool_metadata_state(.sum();// Compaction does not rebudget source records as a normal inference request.// Passthrough bytes are also excluded from model token estimates.- assert!(metadata_bytes > 32 * 1024);+ assert!(metadata_bytes > 128 * 1024);if !metadata_enabled {let mut config = (*session.get_config().await).clone();diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rsindex db8f8e6aa6..418d399999 100644--- a/codex-rs/core/src/tools/executed_tool_calls.rs+++ b/codex-rs/core/src/tools/executed_tool_calls.rs@@ -344,6 +344,10 @@ impl ExecutedToolCalls {let retained = self.retained_direct_metadata_bytes.load(Ordering::Relaxed);let available = MAX_RETAINED_DIRECT_METADATA_BYTES.saturating_sub(retained);let mut bytes = executed_tool_call_metadata_bytes(item);+ if bytes > available {+ item.retain_tool_resource_access();+ bytes = executed_tool_call_metadata_bytes(item);+ }if bytes > available {item.clear_tool_result_metadata();bytes = executed_tool_call_metadata_bytes(item);diff --git a/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs b/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rsindex 7f79e1d227..f4d3176161 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@@ -154,7 +154,7 @@ fn failed_compaction_preserves_observations_absent_from_trimmed_retries() {assert!(recorder.record_tool_result_metadata(&source,&format!("nested-{index}"),- &json!({"provider": "x".repeat(7 * 1024)}),+ &json!({"provider": "x".repeat(24 * 1024)}),));}}@@ -189,7 +189,7 @@ fn compaction_bounds_code_mode_metadata_without_rebudgeting_direct_history() {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..6 {+ for index in 0..24 {let origin = format!("exec-{index}");let cell = CellId::new(format!("cell-{index}"));recorder.start_cell(&cell, &origin);@@ -204,7 +204,7 @@ fn compaction_bounds_code_mode_metadata_without_rebudgeting_direct_history() {history.extend([exec_input(&origin), exec_output(&origin)]);}let direct_start = history.len();- for index in 0..6 {+ 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})));@@ -219,7 +219,7 @@ fn compaction_bounds_code_mode_metadata_without_rebudgeting_direct_history() {.iter().map(executed_tool_call_metadata_bytes).sum::<usize>()- > MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT+ > 128 * 1024);let mut compact = history.clone();@@ -230,14 +230,14 @@ fn compaction_bounds_code_mode_metadata_without_rebudgeting_direct_history() {.iter().map(executed_tool_call_metadata_bytes).sum::<usize>()- <= MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT+ <= 128 * 1024);- let mut newest = exec_output("exec-5");+ let mut newest = exec_output("exec-23");newest.append_executed_tool_calls(vec![ExecutedToolCall::new("nested_tool".to_string(),arguments,)]);- newest.set_tool_call_cell_id("exec-5");+ newest.set_tool_call_cell_id("exec-23");newest.mark_tool_calls_complete();assert_eq!(compact[direct_start - 1], newest);assert_ne!(tool_calls_complete(&compact[1]), Some(true));@@ -269,15 +269,21 @@ fn compaction_keeps_direct_outputs_in_code_mode_binding_validation() {#[test]fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {let recorder = new_recorder(InitialHistory::New);+ let resource_access = json!({"resource_coverage": "complete", "resources": []});let mut call = ExecutedToolCall::new("test_tool".to_string(), json!({"argument": "kept"}));call.set_tool_result_metadata(ToolResultMetadata::new(&json!({"provider": "x".repeat(1024),+ "openai/resource_access": resource_access,})));let mut first = output("first");recorder.attach_direct_call_to_output(&mut first,Some((call.clone(), recorder.reserve_direct_call().unwrap())),);+ let mut expected_first = output("first");+ expected_first.append_executed_tool_calls(vec![call.clone()]);+ expected_first.mark_tool_calls_complete();+ assert_eq!(first, expected_first);let full_bytes = executed_tool_call_metadata_bytes(&first);assert!(full_bytes > 0);assert_eq!(@@ -287,10 +293,39 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {full_bytes,);+ let mut resource_only_call = call.clone();+ resource_only_call.set_tool_result_metadata(ToolResultMetadata::new(&json!({+ "openai/resource_access": resource_access,+ })));+ let mut resource_only_output = ResponseItem::from(ResponseInputItem::FunctionCallOutput {+ call_id: "resource-only".to_string(),+ output: FunctionCallOutputPayload::from_text("ordinary result".to_string()),+ });+ let mut expected_resource_only = resource_only_output.clone();+ expected_resource_only.append_executed_tool_calls(vec![resource_only_call]);+ expected_resource_only.mark_tool_calls_complete();+ let resource_only_bytes = executed_tool_call_metadata_bytes(&expected_resource_only);+ assert!(full_bytes > resource_only_bytes);+ recorder.retained_direct_metadata_bytes.store(+ MAX_RETAINED_DIRECT_METADATA_BYTES - resource_only_bytes,+ Ordering::Relaxed,+ );+ recorder.clone().attach_direct_call_to_output(+ &mut resource_only_output,+ Some((call.clone(), recorder.reserve_direct_call().unwrap())),+ );+ assert_eq!(resource_only_output, expected_resource_only);+ assert_eq!(+ recorder+ .retained_direct_metadata_bytes+ .load(Ordering::Relaxed),+ MAX_RETAINED_DIRECT_METADATA_BYTES,+ );+let mut without_result = first.clone();without_result.clear_tool_result_metadata();let call_bytes = executed_tool_call_metadata_bytes(&without_result);- assert!(full_bytes > call_bytes);+ assert!(resource_only_bytes > call_bytes);recorder.retained_direct_metadata_bytes.store(MAX_RETAINED_DIRECT_METADATA_BYTES - call_bytes,Ordering::Relaxed,@@ -302,6 +337,13 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {&mut second,Some((call.clone(), recorder.reserve_direct_call().unwrap())),);+ let mut expected_second = output("second");+ expected_second.append_executed_tool_calls(vec![ExecutedToolCall::new(+ "test_tool".to_string(),+ json!({"argument": "kept"}),+ )]);+ expected_second.mark_tool_calls_complete();+ assert_eq!(second, expected_second);let second_metadata = second.executed_tool_call_metadata().expect("call remains when only its result metadata exceeds the budget");@@ -613,7 +655,7 @@ fn executed_tool_call_recorder_bounds_retained_history_and_keeps_latest_calls().map(|retained| serialized_json_bytes(&retained.calls)).sum::<serde_json::Result<usize>>().expect("retained calls must serialize");- assert!(retained_bytes <= MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT);+ assert!(retained_bytes <= 128 * 1024);let metadata = prompt.iter()@@ -901,7 +943,7 @@ 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 = 32 * 1024;+ let request_budget = 128 * 1024;let recorder = new_recorder(InitialHistory::New);let cell = CellId::new("clean-overflow-cell".to_string());recorder.start_cell(&cell, "exec-clean");@@ -912,7 +954,7 @@ fn unrelated_raw_overflow_retains_a_complete_exec_within_the_request_budget() {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..6)+ (0..24).map(|index| ExecutedToolCall::new(format!("direct-{index}"), arguments.clone())).collect(),);@@ -1167,7 +1209,22 @@ fn request_truncation_prevents_completion_after_compaction() {);}- let mut initial = [exec_input("exec"), exec_output("exec")];+ let mut initial = vec![exec_input("exec"), exec_output("exec")];+ for index in 0..3 {+ 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!(initial[1]@@ -1266,7 +1323,7 @@ fn untracked_history_budget_loss_keeps_later_wait_incomplete() {/*original_bytes*/ 8192,);let mut prompt = vec![exec_input("exec"), exec_output("exec")];- for index in 0..64 {+ for index in 0..256 {let mut item = output(&format!("untracked-{index}"));item.append_executed_tool_calls(vec![ExecutedToolCall::new("other_tool".to_string(),@@ -1291,11 +1348,11 @@ fn result_metadata_shedding_preserves_completion_after_compaction() {let cell_id = CellId::new("compacted-cell".to_string());recorder.start_cell(&cell_id, "exec");- let argument_bytes = MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - 256;+ let argument_bytes = MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT / 5 - 256;let arguments = json!({"payload": "x".repeat(argument_bytes - r#"{"payload":""}"#.len()),});- for index in 0..4 {+ for index in 0..5 {recorder.record_nested_tool_call(cell_id.clone(),format!("nested-{index}"),@@ -1312,12 +1369,15 @@ fn result_metadata_shedding_preserves_completion_after_compaction() {&mut [exec_input("exec"), exec_output("exec")],&mut retry_cache,);- // This snapshot fits alone, but pushes the four calls over the aggregate budget.- assert!(recorder.record_tool_result_metadata(- &source,- "nested-0",- &json!({ "provider_data": "x".repeat(4 * 1024) }),- ));+ // 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, 2, 3, 4] {+ assert!(recorder.record_tool_result_metadata(+ &source,+ &format!("nested-{index}"),+ &large_metadata,+ ));+ }assert!(recorder.record_tool_result_metadata(&source,@@ -1330,10 +1390,14 @@ fn result_metadata_shedding_preserves_completion_after_compaction() {.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); 4];- for call in &mut expected_calls[..2] {- call.set_tool_result_metadata(ToolResultMetadata::new(&json!("omitted_due_to_size_limit")));+ let mut expected_calls = vec![ExecutedToolCall::new("nested_tool".to_string(), arguments); 5];+ for call in &mut expected_calls[2..] {+ call.set_tool_result_metadata(ToolResultMetadata::new(&large_metadata));}+ expected_calls[0]+ .set_tool_result_metadata(ToolResultMetadata::new(&json!("omitted_due_to_size_limit")));+ expected_calls[1]+ .set_tool_result_metadata(ToolResultMetadata::new(&json!({ "status": "unavailable" })));assert_eq!(calls, &expected_calls);let mut retry = [exec_output("exec")];assert!(recorder.attach_pending_to_prompt(&mut retry, &mut retry_cache));diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rsindex f06e0c2246..b753df9674 100644--- a/codex-rs/core/tests/suite/code_mode.rs+++ b/codex-rs/core/tests/suite/code_mode.rs@@ -1402,7 +1402,7 @@ async fn code_mode_tool_call_completeness_is_private_and_opt_in(r#"const args = { barrier: { id: "", participants: 1 } };args.barrier.id = "x".repeat(8192 - JSON.stringify(args).length);-for (let index = 0; index < 4; index++) await tools.test_sync_tool(args);+for (let index = 0; index < 17; index++) await tools.test_sync_tool(args);text("done");yield_control();await new Promise(() => {});@@ -2010,6 +2010,379 @@ enum ResultMetadataAnalytics {HostDisabled(Option<bool>),}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn direct_result_metadata_retained_budget_preserves_resource_access() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let arguments = serde_json::json!({ "search": "retained-budget" });+ let resource_access = serde_json::json!({+ "schema_version": 1,+ "resource_coverage": "complete",+ "resources": [],+ });+ let resource_only = serde_json::json!({ "openai/resource_access": resource_access });+ let result_metadata = serde_json::json!({+ "payload": "x".repeat(31 * 1024),+ "openai/resource_access": resource_access,+ });+ let metadata_bytes = serde_json::to_vec(&result_metadata)?.len();+ assert!(metadata_bytes < 32 * 1024);+ assert!(metadata_bytes * 33 > 1024 * 1024);+ let apps_server = mount_result_metadata_app(+ &server,+ Some(result_metadata.clone()),+ /*is_error*/ false,+ )+ .await?;+ let mut builder =+ result_metadata_apps_builder(apps_server.chatgpt_base_url, "[email protected]").with_config(+ |config| {+ config.features.disable(Feature::CodeModeOnly).unwrap();+ config.features.disable(Feature::CodeMode).unwrap();+ },+ );+ let test = builder.build_with_auto_env(&server).await?;+ let call_ids = (0..33)+ .map(|index| format!("call-{index}"))+ .collect::<Vec<_>>();+ let mut events = call_ids[..32]+ .iter()+ .map(|call_id| {+ responses::ev_function_call_with_namespace(+ call_id,+ "mcp__codex_apps__messagesearch",+ RESULT_METADATA_TOOL,+ &arguments.to_string(),+ )+ })+ .collect::<Vec<_>>();+ events.push(ev_completed("resp-1"));+ let initial = responses::mount_sse_once(&server, sse(events)).await;+ // Cross the retained-history limit after the first batch has finished, regardless of order.+ let overflow = responses::mount_sse_once(+ &server,+ sse(vec![+ responses::ev_function_call_with_namespace(+ &call_ids[32],+ "mcp__codex_apps__messagesearch",+ RESULT_METADATA_TOOL,+ &arguments.to_string(),+ ),+ ev_completed("resp-2"),+ ]),+ )+ .await;+ let completion = responses::mount_sse_once(&server, sse(vec![ev_completed("resp-3")])).await;+ test.submit_turn("Search the connected app 33 times")+ .await?;+ let initial = initial.single_request();+ assert!(initial.has_message_with_input_texts("user", |texts| {+ texts == ["Search the connected app 33 times"]+ }));+ assert!(+ !tool_names(&initial.body_json())+ .iter()+ .any(|name| name == "exec")+ );+ for (request, expected_calls) in [+ (overflow.single_request(), &call_ids[..32]),+ (completion.single_request(), &call_ids[..]),+ ] {+ for call_id in expected_calls {+ let output = request.function_call_output(call_id);+ assert_eq!(+ &output["output"].as_array().expect("direct output content")[1..],+ &[serde_json::json!({+ "type": "input_text",+ "text": RESULT_METADATA_PRIVATE_RESULT,+ })],+ );+ }+ }+ let calls = recorded_apps_tool_calls(&server).await;+ assert_eq!(calls.len(), call_ids.len());+ for call in calls {+ assert_eq!(call["params"]["name"], RESULT_METADATA_TOOL);+ assert_eq!(call["params"]["arguments"], arguments);+ }+ // The request-metadata helper reapplies the smaller 128 KiB budget, hiding this boundary.+ let history = test.codex.conversation_history_snapshot().await;+ assert!(+ history+ .items()+ .map(codex_protocol::models::executed_tool_call_metadata_bytes)+ .sum::<usize>()+ <= 1024 * 1024+ );+ let outputs = history+ .items()+ .filter(|item| matches!(item, ResponseItem::FunctionCallOutput { .. }))+ .collect::<Vec<_>>();+ assert_eq!(outputs.len(), call_ids.len());+ for (index, call_id) in call_ids.iter().enumerate() {+ let item = outputs+ .iter()+ .find(|item| matches!(item, ResponseItem::FunctionCallOutput { call_id: Some(id), .. } if id == call_id))+ .expect("retained Direct output");+ if let ResponseItem::FunctionCallOutput { output, .. } = item {+ assert_eq!(output.success, Some(true));+ }+ let output = serde_json::to_value(item)?;+ let metadata = &output["internal_chat_message_metadata_passthrough"];+ assert_eq!(metadata["tool_calls_complete"], true);+ let calls = metadata["executed_tool_calls"].as_array().unwrap();+ assert_eq!(calls.len(), 1);+ assert!(+ calls[0]["name"]+ .as_str()+ .unwrap()+ .ends_with(RESULT_METADATA_TOOL)+ );+ assert_eq!(calls[0]["arguments"], arguments);+ assert_eq!(+ calls[0]["tool_result_metadata"],+ if index < 32 {+ &result_metadata+ } else {+ &resource_only+ }+ .clone(),+ );+ }+ test.codex.shutdown_and_wait().await?;+ Ok(())+}++#[test_case(ToolMode::Direct; "direct")]+#[test_case(ToolMode::CodeModeOnly; "code_mode")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn result_metadata_budget_preserves_smaller_results(tool_mode: ToolMode) -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let arguments = [+ serde_json::json!({ "search": "large" }),+ serde_json::json!({ "search": "medium-1" }),+ serde_json::json!({ "search": "medium-2" }),+ serde_json::json!({ "search": "medium-3" }),+ serde_json::json!({ "search": "medium-4" }),+ serde_json::json!({ "search": "medium-5" }),+ serde_json::json!({ "search": "oversized" }),+ serde_json::json!({ "search": "small" }),+ ];+ let resource_access = serde_json::json!({+ "schema_version": 1,+ "resource_coverage": "complete",+ "resources": [],+ });+ let resource_only = serde_json::json!({ "openai/resource_access": resource_access });+ let result_metadata = [+ serde_json::json!({+ "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": "o".repeat(40 * 1024),+ "openai/resource_access": resource_access,+ }),+ serde_json::json!({ "status": "ok" }),+ ];+ let metadata_sizes = result_metadata+ .iter()+ .map(|metadata| serde_json::to_vec(metadata).unwrap().len())+ .collect::<Vec<_>>();+ assert!(metadata_sizes[..6].iter().all(|bytes| *bytes < 32 * 1024));+ assert!(metadata_sizes[..6].iter().sum::<usize>() > 128 * 1024);+ assert!(metadata_sizes[6] > 32 * 1024);+ assert!(metadata_sizes[7] < 32 * 1024);+ for (arguments, metadata) in arguments.iter().zip(&result_metadata) {+ let result = serde_json::json!({+ "content": [{ "type": "text", "text": RESULT_METADATA_PRIVATE_RESULT }],+ "isError": false,+ "_meta": metadata,+ });+ Mock::given(method("POST"))+ .and(path("/api/codex/ps/mcp"))+ .and(body_partial_json(serde_json::json!({+ "method": "tools/call",+ "params": { "arguments": arguments },+ })))+ .respond_with(move |request: &Request| {+ let request: Value = serde_json::from_slice(&request.body).unwrap();+ ResponseTemplate::new(200).set_body_json(serde_json::json!({+ "jsonrpc": "2.0",+ "id": request["id"],+ "result": result,+ }))+ })+ .with_priority(/*p*/ 1)+ .mount(&server)+ .await;+ }+ // Exact argument matches take precedence over the shared fallback mounted afterward.+ let apps_server = mount_result_metadata_app(+ &server, /*result_metadata*/ None, /*is_error*/ false,+ )+ .await?;+ let direct = tool_mode == ToolMode::Direct;+ let mut builder =+ result_metadata_apps_builder(apps_server.chatgpt_base_url, "[email protected]").with_config(+ move |config| {+ if direct {+ config.features.disable(Feature::CodeModeOnly).unwrap();+ config.features.disable(Feature::CodeMode).unwrap();+ }+ },+ );+ let test = builder.build_with_auto_env(&server).await?;+ let call_ids = [+ "call-1", "call-2", "call-3", "call-4", "call-5", "call-6", "call-7", "call-8",+ ];+ let mut events = if direct {+ arguments+ .iter()+ .zip(call_ids)+ .map(|(arguments, call_id)| {+ responses::ev_function_call_with_namespace(+ call_id,+ "mcp__codex_apps__messagesearch",+ RESULT_METADATA_TOOL,+ &arguments.to_string(),+ )+ })+ .collect::<Vec<_>>()+ } else {+ let arguments = serde_json::to_string(&arguments)?;+ let code = format!(+ "const tool = ALL_TOOLS.find(({{ name }}) => name.endsWith(\"{RESULT_METADATA_TOOL}\")); \+ const results = []; \+ for (const args of {arguments}) {{ \+ const result = await tools[tool.name](args); \+ results.push({{ content: result.content, isError: Boolean(result.isError), \+ hasMeta: Object.hasOwn(result, \"_meta\") }}); \+ }} \+ text(JSON.stringify(results));"+ );+ vec![ev_custom_tool_call("call-1", "exec", &code)]+ };+ events.push(ev_completed("resp-1"));+ let initial = responses::mount_sse_once(&server, sse(events)).await;+ let follow_up = responses::mount_sse_once(&server, sse(vec![ev_completed("resp-2")])).await;+ test.submit_turn("Search the connected app eight times")+ .await?;+ let initial = initial.single_request();+ assert!(initial.has_message_with_input_texts("user", |texts| {+ texts == ["Search the connected app eight times"]+ }));+ assert_eq!(+ tool_names(&initial.body_json())+ .iter()+ .any(|name| name == "exec"),+ !direct,+ );+ let request = follow_up.single_request();+ let mut actual_arguments = recorded_apps_tool_calls(&server)+ .await+ .into_iter()+ .map(|call| {+ assert_eq!(call["params"]["name"], RESULT_METADATA_TOOL);+ call["params"]["arguments"].clone()+ })+ .collect::<Vec<_>>();+ actual_arguments.sort_by_key(Value::to_string);+ assert_eq!(actual_arguments, arguments);+ if direct {+ for call_id in call_ids {+ let output = request.function_call_output(call_id);+ assert_eq!(+ &output["output"].as_array().expect("direct output content")[1..],+ &[serde_json::json!({+ "type": "input_text",+ "text": RESULT_METADATA_PRIVATE_RESULT,+ })],+ );+ assert!(!output["output"].to_string().contains("payload"));+ }+ } else {+ let (body, success) = custom_tool_output_body_and_success(&request, "call-1");+ assert_ne!(success, Some(false), "Code Mode failed: {body}");+ assert_eq!(+ serde_json::from_str::<Value>(&body)?,+ serde_json::json!(vec![+ serde_json::json!({+ "content": [{ "type": "text", "text": RESULT_METADATA_PRIVATE_RESULT }],+ "isError": false,+ "hasMeta": false,+ });+ arguments.len()+ ]),+ );+ }+ let captured = codex_core::test_support::history_with_tool_call_metadata(&test.codex).await;+ if direct {+ for item in &captured {+ if let ResponseItem::FunctionCallOutput { output, .. } = item {+ assert_eq!(output.success, Some(true));+ }+ }+ }+ assert!(+ captured+ .iter()+ .map(codex_protocol::models::executed_tool_call_metadata_bytes)+ .sum::<usize>()+ <= 128 * 1024+ );+ let captured = serde_json::to_value(captured)?;+ for (input, expected_metadata) in [+ // Custom inference endpoints must strip raw metadata, including omission markers.+ (request.input(), None),+ (+ captured.as_array().unwrap().clone(),+ Some([+ resource_only.clone(),+ result_metadata[1].clone(),+ result_metadata[2].clone(),+ result_metadata[3].clone(),+ result_metadata[4].clone(),+ result_metadata[5].clone(),+ resource_only.clone(),+ result_metadata[7].clone(),+ ]),+ ),+ ] {+ let mut calls = Vec::new();+ for output in &input {+ let metadata = &output["internal_chat_message_metadata_passthrough"];+ if let Some(recorded) = metadata["executed_tool_calls"].as_array() {+ assert_eq!(metadata["tool_calls_complete"], true);+ calls.extend(recorded.iter().cloned());+ }+ }+ assert_eq!(calls.len(), arguments.len());+ let expected_calls = arguments+ .iter()+ .enumerate()+ .map(|(index, arguments)| {+ let name = calls[index]["name"].as_str().unwrap();+ assert!(name.ends_with(RESULT_METADATA_TOOL));+ let mut call = serde_json::json!({ "name": name, "arguments": arguments });+ if let Some(metadata) = &expected_metadata {+ call["tool_result_metadata"] = metadata[index].clone();+ }+ call+ })+ .collect::<Vec<_>>();+ assert_eq!(calls, expected_calls);+ }+ test.codex.shutdown_and_wait().await?;+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]#[test_case(true, true, true, false, "[email protected]", ToolMode::CodeModeOnly, ResultMetadataAnalytics::Config(None); "copies_full_metadata_without_rules")]#[test_case(true, true, true, true, "[email protected]", ToolMode::CodeModeOnly, ResultMetadataAnalytics::Config(None); "accepted_error_keeps_metadata")]@@ -2067,8 +2440,8 @@ async fn result_metadata_follows_call_binding(.with_config(move |config| {config.analytics_enabled = analytics_enabled;if direct {- config.features.disable(Feature::CodeMode).unwrap();config.features.disable(Feature::CodeModeOnly).unwrap();+ config.features.disable(Feature::CodeMode).unwrap();}if !metadata_enabled {configdiff --git a/codex-rs/core/tests/suite/direct_tool_metadata.rs b/codex-rs/core/tests/suite/direct_tool_metadata.rsindex 9c3bffaf71..a6bb8059e4 100644--- a/codex-rs/core/tests/suite/direct_tool_metadata.rs+++ b/codex-rs/core/tests/suite/direct_tool_metadata.rs@@ -203,7 +203,7 @@ async fn direct_call_metadata_during_compaction_respects_provider_support(}#[test_case(false, 0; "metadata disabled")]-#[test_case(true, 6; "request budget exceeded")]+#[test_case(true, 24; "request budget exceeded")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn direct_function_and_tool_search_mark_complete_attempts(metadata_enabled: bool,@@ -211,7 +211,7 @@ async fn direct_function_and_tool_search_mark_complete_attempts() -> Result<()> {skip_if_no_network!(Ok(()));- let request_budget = 32 * 1024;+ let request_budget = 128 * 1024;let server = start_mock_server().await;let mut builder = test_codex().with_config(move |config| {configure_search_capable_model(config);diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rsindex 227042c596..3fe38189be 100644--- a/codex-rs/protocol/src/models/executed_tool_calls.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs@@ -1,3 +1,4 @@+use std::collections::BTreeMap;use std::collections::HashSet;use schemars::JsonSchema;@@ -14,7 +15,10 @@ 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 = 32 * 1024;+const MAX_EXECUTED_TOOL_CALL_METADATA_BYTES: usize = 128 * 1024;+/// Maximum serialized raw metadata captured from one tool result.+const MAX_TOOL_RESULT_METADATA_BYTES: usize = 32 * 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 =b"\"internal_chat_message_metadata_passthrough\":".len();@@ -125,23 +129,100 @@ fn bound_executed_tool_calls_for_prompt_with_priority(bytes.saturating_add(executed_tool_call_metadata_bytes(item))})};- if metadata_bytes(items) <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {+ let mut total_metadata_bytes = metadata_bytes(items);+ if total_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {return;}// Raw result metadata must not displace existing source evidence, calls or completion proof.- for item in items.iter_mut() {+ // Shed the largest values first so one large result does not discard unrelated small results.+ let omitted = ToolResultMetadata::omitted_due_to_size_limit();+ let omitted_bytes = serde_json::to_vec(&omitted).map_or(usize::MAX, |value| value.len());+ 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){- for call in metadata.executed_tool_calls.iter_mut().flatten() {+ // 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()+ .flatten()+ .enumerate()+ {if call.tool_result_metadata.is_some() {- call.tool_result_metadata = ToolResultMetadata::omitted_due_to_size_limit();+ let bytes = serde_json::to_vec(&call.tool_result_metadata)+ .map_or(usize::MAX, |value| value.len());+ result_metadata.push((+ bytes,+ eviction_order,+ call_index,+ &mut call.tool_result_metadata,+ ));}}}}+ result_metadata.sort_by_key(|(bytes, order, call_index, _)| {+ (std::cmp::Reverse(*bytes), *order, *call_index)+ });+ for (bytes, _, _, metadata) in &mut result_metadata {+ if total_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {+ break;+ }+ if metadata.retain_resource_access() {+ let retained_bytes =+ serde_json::to_vec(&**metadata).map_or(usize::MAX, |value| value.len());+ total_metadata_bytes =+ total_metadata_bytes.saturating_sub(bytes.saturating_sub(retained_bytes));+ *bytes = retained_bytes;+ } else if *bytes > omitted_bytes {+ **metadata = omitted.clone();+ total_metadata_bytes = total_metadata_bytes.saturating_sub(*bytes - omitted_bytes);+ *bytes = omitted_bytes;+ }+ }+ // Resource evidence is optional too; it must not displace the call inventory.+ result_metadata.sort_by_key(|(bytes, order, call_index, _)| {+ (std::cmp::Reverse(*bytes), *order, *call_index)+ });+ for (bytes, _, _, metadata) in &mut result_metadata {+ if total_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {+ break;+ }+ // An omission marker can be larger than a small object, including an empty `_meta`.+ if *bytes > omitted_bytes {+ **metadata = omitted.clone();+ total_metadata_bytes = total_metadata_bytes.saturating_sub(*bytes - omitted_bytes);+ *bytes = omitted_bytes;+ }+ }+ // Use the updated sizes: markers should be removed before smaller provider metadata.+ result_metadata.sort_by_key(|(bytes, order, call_index, metadata)| {+ (+ std::cmp::Reverse(*bytes),+ metadata.0 != omitted.0,+ *order,+ *call_index,+ )+ });+ for (bytes, _, _, metadata) in result_metadata {+ if total_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {+ break;+ }+ *metadata = ToolResultMetadata::default();+ // The required name and arguments always precede this optional serialized field.+ total_metadata_bytes = total_metadata_bytes+ .saturating_sub(bytes.saturating_add(b",\"tool_result_metadata\":".len()));+ }+ // Recheck the serialized request rather than relying on the incremental size accounting.if metadata_bytes(items) <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {return;}@@ -247,7 +328,7 @@ pub struct ExecutedToolCall {tool_result_metadata: ToolResultMetadata,}-/// An entire MCP result's `_meta`, or a string marker when omitted due to the size limit.+/// MCP result metadata, optionally reduced to resource evidence, or a size-omission marker.#[derive(Clone, Default, Serialize, PartialEq, Eq)]#[serde(transparent)]pub struct ToolResultMetadata(Option<serde_json::Value>);@@ -259,14 +340,35 @@ impl std::fmt::Debug for ToolResultMetadata {}impl ToolResultMetadata {- /// Bounds serialization before cloning arbitrary MCP metadata; no keys are filtered.+ /// Bounds serialization before cloning, retaining resource evidence if the full result is too large.pub fn new(metadata: &serde_json::Value) -> Self {- let mut limit = MetadataSizeLimit(MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);+ let mut limit = MetadataSizeLimit(MAX_TOOL_RESULT_METADATA_BYTES);if serde_json::to_writer(&mut limit, metadata).is_ok() {- Self(Some(metadata.clone()))- } else {- Self::omitted_due_to_size_limit()+ return Self(Some(metadata.clone()));}+ if let Some(resource_access) = metadata.get(RESOURCE_ACCESS_METADATA_KEY) {+ let resource_metadata =+ BTreeMap::from([(RESOURCE_ACCESS_METADATA_KEY, resource_access)]);+ let mut limit = MetadataSizeLimit(MAX_TOOL_RESULT_METADATA_BYTES);+ if serde_json::to_writer(&mut limit, &resource_metadata).is_ok() {+ return Self(Some(serde_json::json!({+ (RESOURCE_ACCESS_METADATA_KEY): resource_access,+ })));+ }+ }+ Self::omitted_due_to_size_limit()+ }++ /// Leaves generic metadata unchanged when it has no resource-access field.+ fn retain_resource_access(&mut self) -> bool {+ let Some(serde_json::Value::Object(metadata)) = self.0.as_mut() else {+ return false;+ };+ if !metadata.contains_key(RESOURCE_ACCESS_METADATA_KEY) {+ return false;+ }+ metadata.retain(|key, _| key == RESOURCE_ACCESS_METADATA_KEY);+ true}fn omitted_due_to_size_limit() -> Self {@@ -524,6 +626,20 @@ impl ResponseItem {}}+ /// Reduces optional results to resource evidence before considering call-inventory loss.+ pub fn retain_tool_resource_access(&mut self) {+ if let Some(metadata) = self+ .internal_chat_message_metadata_passthrough_mut()+ .and_then(Option::as_mut)+ {+ for call in metadata.executed_tool_calls.iter_mut().flatten() {+ if !call.tool_result_metadata.retain_resource_access() {+ call.tool_result_metadata = ToolResultMetadata::default();+ }+ }+ }+ }+/// Replaces an over-budget output's calls with its own omission marker.fn bound_executed_tool_calls_with_budget(&mut self, max_metadata_bytes: usize) {let Some(metadata) = self.executed_tool_call_metadata() else {diff --git a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs b/codex-rs/protocol/src/models/executed_tool_calls_tests.rsindex 5747aabab1..7d033a27a1 100644--- a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs@@ -100,7 +100,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {};for with_turn_id in [true, false] {- let mut items = (0..1_000)+ let mut items = (0..4_000).map(|index| {let mut item = output(&index.to_string());*item@@ -133,7 +133,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {.flatten().collect::<Vec<_>>();// Shares smaller than a local marker omit that output; surviving calls stay unchanged.- assert!(!calls.is_empty() && calls.len() < 1_000);+ assert!(!calls.is_empty() && calls.len() < 4_000);assert!(calls.iter().all(|call| {**call == ExecutedToolCall::new(String::new(), serde_json::Value::Null)}));@@ -199,7 +199,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {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);- assert!(6 * argument_bytes > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);+ assert!(24 * 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();@@ -208,7 +208,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {for item in &mut items[..2] {item.set_tool_call_cell_id("cell-A");}- let calls = vec![ExecutedToolCall::new("test_tool".to_string(), arguments); 6];+ let calls = vec![ExecutedToolCall::new("test_tool".to_string(), arguments); 24];items[0].append_executed_tool_calls(calls.clone());items[2].append_executed_tool_calls(vec![ExecutedToolCall::new("test_tool".to_string(),@@ -230,7 +230,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {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(5));+ assert_eq!(truncation.omitted_calls, Some(23));assert_eq!(bounded[1].executed_tool_call_metadata()@@ -249,7 +249,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {.truncation().unwrap().omitted_calls,- Some(11),+ Some(47),);}@@ -263,7 +263,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {"test_tool".to_string(),serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - 256) }),);- 4+ 16]);items[1].mark_tool_calls_complete();let expected = items.clone();@@ -299,7 +299,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {metadata_bytes(std::slice::from_ref(&item))?,executed_tool_call_metadata_bytes(&item),);- let mut items = vec![item; 2_000];+ 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);@@ -307,7 +307,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {.iter().filter(|item| executed_tool_call_metadata_bytes(item) > 0).count();- assert!(retained > 0 && retained < 2_000);+ assert!(retained > 0 && retained < 8_000);for item in &mut items {assert!(item.executed_tool_call_metadata()@@ -315,7 +315,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {);item.clear_executed_tool_calls();}- assert_eq!(items, vec![without_marker; 2_000]);+ assert_eq!(items, vec![without_marker; 8_000]);}Ok(())@@ -509,6 +509,10 @@ fn tool_result_metadata_is_host_only_bounded_and_redacted() -> Result<()> {"arbitrary-key": { "secret": "not-for-debug", "ids": [1, "é", null] },"other": false,}),+ serde_json::json!({+ "openai/resource_access": { "resources": ["not-for-debug"] },+ "other": "preserved when the full metadata fits",+ }),serde_json::json!({}),serde_json::json!(null),] {@@ -533,7 +537,7 @@ fn tool_result_metadata_is_host_only_bounded_and_redacted() -> Result<()> {}let exact_limit = serde_json::json!({- "value": "x".repeat(MAX_EXECUTED_TOOL_CALL_METADATA_BYTES - r#"{"value":""}"#.len()),+ "value": "x".repeat(MAX_TOOL_RESULT_METADATA_BYTES - r#"{"value":""}"#.len()),});let capture = ToolResultMetadata::new(&exact_limit);assert!(capture.is_some());@@ -543,8 +547,7 @@ fn tool_result_metadata_is_host_only_bounded_and_redacted() -> Result<()> {exact_limit);// JSON escaping counts toward the bound, not just the in-memory string length.- let oversized =- serde_json::json!({ "value": "\0".repeat(MAX_EXECUTED_TOOL_CALL_METADATA_BYTES / 2) });+ let oversized = serde_json::json!({ "value": "\0".repeat(MAX_TOOL_RESULT_METADATA_BYTES / 2) });let capture = ToolResultMetadata::new(&oversized);assert!(capture.is_some());call.set_tool_result_metadata(capture);@@ -561,6 +564,39 @@ fn tool_result_metadata_is_host_only_bounded_and_redacted() -> Result<()> {serde_json::from_value::<ExecutedToolCall>(wire)?,without_metadata);++ let resource_access = serde_json::json!({+ "schema_version": 1,+ "resource_coverage": "incomplete",+ "resources": [{ "id": "not-for-debug" }],+ "reasons": ["tool_error"],+ });+ let oversized = serde_json::json!({+ "openai/resource_access": resource_access,+ "other": "x".repeat(MAX_TOOL_RESULT_METADATA_BYTES),+ });+ call.set_tool_result_metadata(ToolResultMetadata::new(&oversized));+ let wire = serde_json::to_value(&call)?;+ assert_eq!(+ wire["tool_result_metadata"],+ serde_json::json!({ "openai/resource_access": resource_access }),+ );+ assert!(!format!("{call:?}").contains("not-for-debug"));+ assert_eq!(+ serde_json::from_value::<ExecutedToolCall>(wire)?,+ without_metadata+ );+ // Do not trim resource lists while preserving a provider's coverage claim.+ let oversized_resources = serde_json::json!({+ "openai/resource_access": {+ "resource_coverage": "complete",+ "resources": ["x".repeat(MAX_TOOL_RESULT_METADATA_BYTES)],+ },+ });+ assert_eq!(+ ToolResultMetadata::new(&oversized_resources),+ ToolResultMetadata::omitted_due_to_size_limit(),+ );Ok(())}@@ -571,7 +607,17 @@ fn raw_result_metadata_is_shed_before_sources_calls_or_completion() -> Result<()r#type: "test_resource".to_string(),id: "R1".to_string(),}]));- let mut items = ["first", "second", "without-metadata"].map(|call_id| {+ 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()),@@ -581,20 +627,16 @@ fn raw_result_metadata_is_shed_before_sources_calls_or_completion() -> Result<()item.mark_tool_calls_complete();item});- let mut expected = items.clone();let metadata = ToolResultMetadata::new(&serde_json::json!({ "large": "x".repeat(20_000) }));- for item in &mut items[..2] {+ for item in &mut items[..7] {first_executed_tool_call(item).unwrap().set_tool_result_metadata(metadata.clone());}- for item in &mut expected[..2] {- first_executed_tool_call(item)- .unwrap()- .set_tool_result_metadata(ToolResultMetadata::new(&serde_json::json!(- "omitted_due_to_size_limit"- )));- }+ let mut expected = items.clone();+ first_executed_tool_call(&mut expected[0])+ .unwrap()+ .set_tool_result_metadata(ToolResultMetadata::omitted_due_to_size_limit());assert!(items.iter()@@ -602,20 +644,193 @@ fn raw_result_metadata_is_shed_before_sources_calls_or_completion() -> Result<().sum::<usize>()> MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);- bound_executed_tool_calls_for_prompt(&mut items);- assert_eq!(items, expected);- assert!(- items- .iter()- .map(executed_tool_call_metadata_bytes)- .sum::<usize>()- <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES- );- bound_executed_tool_calls_for_prompt(&mut items);- assert_eq!(items, expected);+ 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 resource_only = serde_json::json!({+ "openai/resource_access": { "resource_coverage": "complete", "resources": [] },+ });+ for (metadata, reduced_index, replacement) in [+ (+ [+ serde_json::json!({}),+ serde_json::json!({ "value": "é".repeat(10_000) }),+ serde_json::json!({ "value": "é".repeat(10_000) }),+ ],+ 1,+ ToolResultMetadata::omitted_due_to_size_limit(),+ ),+ (+ [+ serde_json::json!({}),+ serde_json::json!({ "value": "x".repeat(8_000) }),+ serde_json::json!({ "value": "\0".repeat(4_500) }),+ ],+ 2,+ ToolResultMetadata::omitted_due_to_size_limit(),+ ),+ (+ [+ serde_json::json!({}),+ serde_json::json!({ "value": "x".repeat(8_000) }),+ serde_json::json!({+ "value": "\0".repeat(4_500),+ "openai/resource_access": resource_only["openai/resource_access"],+ }),+ ],+ 2,+ ToolResultMetadata::new(&resource_only),+ ),+ ] {+ let mut metadata = metadata.to_vec();+ metadata.extend(vec![+ serde_json::json!({ "padding": "x".repeat(17_000) });+ 6+ ]);+ let mut item = output("exec");+ item.append_executed_tool_calls(+ metadata+ .iter()+ .enumerate()+ .map(|(index, metadata)| {+ let mut call = ExecutedToolCall::new(+ format!("tool_{index}"),+ serde_json::json!({ "argument": index }),+ );+ call.set_tool_result_sources(ToolResultSources::new(vec![ToolResultSource {+ r#type: "test_resource".to_string(),+ id: format!("R{index}"),+ }]));+ call.set_tool_result_metadata(ToolResultMetadata::new(metadata));+ call+ })+ .collect(),+ );+ 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);+ let mut expected = item.clone();+ expected+ .ensure_tool_call_metadata()+ .unwrap()+ .executed_tool_calls+ .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,+ ] {+ 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();+ 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() {+ call.arguments = ExecutedToolCallArguments::Raw(serde_json::json!("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());+ // First downgrade the larger, newer result, then remove the older marker. The+ // removal order must use the updated sizes rather than the original raw size.+ 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),+ })));+ 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 {@@ -627,7 +842,7 @@ fn result_metadata_markers_do_not_displace_existing_evidence() {r#type: "test_resource".to_string(),id: "R1".to_string(),}]));- item.append_executed_tool_calls(vec![call; 4]);+ item.append_executed_tool_calls(vec![call; 20]);item.set_tool_call_cell_id("exec");item.mark_tool_calls_complete();let remaining_bytes =@@ -638,22 +853,29 @@ fn result_metadata_markers_do_not_displace_existing_evidence() {.executed_tool_calls.as_mut().unwrap();+ let call_count = calls.len();for (index, call) in calls.iter_mut().enumerate() {// Fill the budget exactly, with every argument still below its individual limit.- call.arguments = ExecutedToolCallArguments::Raw(serde_json::json!(- "x".repeat(remaining_bytes / 4 + usize::from(index < remaining_bytes % 4))- ));+ call.arguments = ExecutedToolCallArguments::Raw(serde_json::json!("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();- first_executed_tool_call(&mut item)- .unwrap()- .set_tool_result_metadata(ToolResultMetadata::new(- &serde_json::json!({ "too-large": "x".repeat(32 * 1024) }),- ));- bound_executed_tool_calls_for_prompt(std::slice::from_mut(&mut item));- assert_eq!(item, expected);+ 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);+ }}