Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Bind direct tool-call metadata to invocation outputs (#45185)

ningyi-oai1715e5507673
diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs
index 27ae9505cd..c5077bf93f 100644
--- a/codex-rs/app-server/src/bespoke_event_handling.rs
+++ b/codex-rs/app-server/src/bespoke_event_handling.rs
@@ -1152,7 +1152,9 @@ pub(crate) async fn apply_bespoke_event_handling(
.send_server_notification(ServerNotification::HookCompleted(notification))
.await;
}
- EventMsg::RawResponseItem(raw_response_item_event) => {
+ EventMsg::RawResponseItem(mut raw_response_item_event) => {
+ // Keep warehouse metadata out of app-server notifications.
+ raw_response_item_event.item.clear_executed_tool_calls();
let mut notification = ServerNotification::RawResponseItemCompleted(
RawResponseItemCompletedNotification {
thread_id: conversation_id.to_string(),
@@ -3164,6 +3166,7 @@ mod tests {
})
);
}
+
Ok(())
}
diff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rs
index f9488fbec6..4bb6eafcfb 100644
--- a/codex-rs/app-server/tests/suite/v2/turn_start.rs
+++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs
@@ -91,6 +91,9 @@ use codex_protocol::openai_models::ReasoningEffort;
use codex_protocol::protocol::MULTI_AGENT_MODE_OPEN_TAG;
use codex_protocol::user_input::MAX_USER_INPUT_TEXT_CHARS;
use codex_utils_absolute_path::test_support::PathExt;
+use core_test_support::apps_test_server::AppsTestServer;
+use core_test_support::apps_test_server::SEARCH_CALENDAR_LIST_TOOL;
+use core_test_support::apps_test_server::SEARCH_CALENDAR_NAMESPACE;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
use core_test_support::skip_if_remote;
@@ -106,7 +109,12 @@ use tempfile::TempDir;
use test_case::test_case;
use tokio::sync::oneshot;
use tokio::time::timeout;
+use wiremock::Mock;
+use wiremock::Request;
use wiremock::ResponseTemplate;
+use wiremock::matchers::body_partial_json;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
use super::analytics::mount_analytics_capture;
use super::analytics::wait_for_analytics_event;
@@ -330,6 +338,187 @@ async fn turn_start_omits_notification_media_without_changing_model_input() -> R
Ok(())
}
+#[tokio::test]
+async fn tool_call_metadata_stays_out_of_raw_response_item_notifications() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let arguments = json!({"query": "redaction"});
+ let result_metadata = json!({"provider/private": {"sentinel": "raw-result-metadata"}});
+ let responses = vec![
+ responses::sse(vec![
+ responses::ev_response_created("resp-1"),
+ responses::ev_function_call_with_namespace(
+ "mcp-call",
+ SEARCH_CALENDAR_NAMESPACE,
+ SEARCH_CALENDAR_LIST_TOOL,
+ &arguments.to_string(),
+ ),
+ responses::ev_completed("resp-1"),
+ ]),
+ create_final_assistant_message_sse_response("Done")?,
+ ];
+ let server = responses::start_mock_server().await;
+ let model = responses::mount_sse_sequence(&server, responses).await;
+ let apps = AppsTestServer::mount(&server).await?;
+ let tool_result = json!({
+ "content": [{"type": "text", "text": "Calendar result"}],
+ "_meta": result_metadata,
+ "isError": false,
+ });
+ Mock::given(method("POST"))
+ .and(path("/api/codex/ps/mcp"))
+ .and(body_partial_json(json!({
+ "method": "tools/call",
+ "params": {"name": "calendar_list_events", "arguments": arguments},
+ })))
+ .respond_with(move |request: &Request| {
+ let request: Value = serde_json::from_slice(&request.body).unwrap();
+ ResponseTemplate::new(200).set_body_json(json!({
+ "jsonrpc": "2.0",
+ "id": request["id"],
+ "result": tool_result,
+ }))
+ })
+ .with_priority(/*p*/ 1)
+ .expect(1)
+ .mount(&server)
+ .await;
+ let codex_home = TempDir::new()?;
+ MockResponsesConfig::new(&server.uri())
+ .with_provider_name("OpenAI")
+ .with_provider_config("supports_websockets = false")
+ .with_root_config(&format!(
+ "chatgpt_base_url = \"{}\"\ncli_auth_credentials_store = \"file\"",
+ apps.chatgpt_base_url
+ ))
+ .enable_feature(Feature::Apps)
+ .enable_feature(Feature::ExecutedToolCallMetadata)
+ .write(codex_home.path())?;
+ write_chatgpt_auth(
+ codex_home.path(),
+ ChatGptAuthFixture::new("chatgpt-test-token")
+ .account_id("account-123")
+ .chatgpt_account_id("account-123")
+ .chatgpt_user_id("user-123")
+ .email("[email protected]"),
+ AuthCredentialsStoreMode::File,
+ )?;
+
+ let mut mcp = TestAppServer::builder()
+ .with_codex_home(codex_home.path())
+ .build_initialized()
+ .await?;
+ let ThreadStartResponse { thread, .. } = mcp
+ .start_thread(ThreadStartParams {
+ model: Some("mock-model".to_string()),
+ experimental_raw_events: true,
+ history_mode: Some(ThreadHistoryMode::Legacy),
+ ..Default::default()
+ })
+ .await?;
+ let rollout_path = thread.path.context("thread rollout path")?;
+ let _: TurnStartResponse = mcp
+ .request(|request_id| ClientRequest::TurnStart {
+ request_id,
+ params: TurnStartParams {
+ thread_id: thread.id,
+ input: vec![V2UserInput::Text {
+ text: "list calendar events".to_string(),
+ text_elements: Vec::new(),
+ }],
+ ..Default::default()
+ },
+ })
+ .await?;
+
+ let raw_params = timeout(DEFAULT_READ_TIMEOUT, async {
+ loop {
+ let notification = mcp
+ .read_stream_until_matching_notification("raw output or turn completion", |n| {
+ matches!(
+ n.method.as_str(),
+ "rawResponseItem/completed" | "turn/completed"
+ )
+ })
+ .await?;
+ if notification.method == "turn/completed" {
+ anyhow::bail!("missing raw tool output notification");
+ }
+ let params = notification.params.context("raw notification params")?;
+ let item = &params["item"];
+ if item["type"] == "function_call_output" && item["call_id"] == "mcp-call" {
+ return Ok::<Value, anyhow::Error>(params);
+ }
+ }
+ })
+ .await??;
+ timeout(
+ DEFAULT_READ_TIMEOUT,
+ mcp.read_stream_until_notification_message("turn/completed"),
+ )
+ .await??;
+
+ let requests = model.requests();
+ assert_eq!(requests.len(), 2);
+ let follow_up = requests[1].body_json();
+ let output = follow_up["input"]
+ .as_array()
+ .context("follow-up model input")?
+ .iter()
+ .find(|item| item["type"] == "function_call_output" && item["call_id"] == "mcp-call")
+ .context("follow-up tool output")?;
+ assert!(serde_json::to_string(&output["output"])?.contains("Calendar result"));
+ assert_eq!(
+ output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"],
+ json!([{"name": "mcp__codex_apps__calendar_list_events", "arguments": arguments}]),
+ );
+ assert_eq!(
+ output["internal_chat_message_metadata_passthrough"]["tool_calls_complete"],
+ true,
+ );
+
+ let raw_output = &raw_params["item"];
+ assert_eq!(raw_output["output"], output["output"]);
+ assert!(!serde_json::to_string(&raw_params)?.contains("raw-result-metadata"));
+ let public_metadata = raw_output["internal_chat_message_metadata_passthrough"]
+ .as_object()
+ .context("public passthrough metadata")?;
+ assert_eq!(
+ public_metadata.get("turn_id").context("public turn id")?,
+ &output["internal_chat_message_metadata_passthrough"]["turn_id"],
+ );
+ for field in ["executed_tool_calls", "tool_calls_complete", "cell_id"] {
+ assert!(
+ public_metadata.get(field).is_none(),
+ "notification leaked {field}"
+ );
+ }
+
+ let status = timeout(DEFAULT_READ_TIMEOUT, mcp.shutdown_gracefully()).await??;
+ assert!(status.success());
+ // Read raw JSON: ResponseItem deserialization intentionally discards host-owned metadata.
+ let rollout = std::fs::read_to_string(rollout_path)?;
+ let entries = rollout
+ .lines()
+ .map(serde_json::from_str::<Value>)
+ .collect::<serde_json::Result<Vec<_>>>()?;
+ let captured = entries
+ .iter()
+ .filter(|entry| entry["type"] == "response_item")
+ .map(|entry| &entry["payload"])
+ .find(|item| item["type"] == "function_call_output" && item["call_id"] == "mcp-call")
+ .context("persisted MCP output")?;
+ assert_eq!(captured["output"], raw_output["output"]);
+ // The custom inference endpoint omits raw metadata, so verify capture in the rollout.
+ let expected_metadata: Option<&Value> = None;
+ assert_eq!(
+ captured["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]
+ .get("tool_result_metadata"),
+ expected_metadata,
+ );
+ Ok(())
+}
+
#[tokio::test]
async fn turn_start_with_empty_input_runs_model_request() -> Result<()> {
let responses = vec![create_final_assistant_message_sse_response("Done")?];
diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rs
index 28bd8bf052..bf3e6b08c5 100644
--- a/codex-rs/core/src/compact.rs
+++ b/codex-rs/core/src/compact.rs
@@ -266,9 +266,12 @@ async fn run_compact_task_inner_impl(
let compaction_response_id = loop {
// Clone is required because of the loop
- let turn_input = history
+ let mut turn_input = history
.clone()
.for_prompt(&turn_context.model_info().input_modalities);
+ sess.services
+ .executed_tool_calls
+ .strip_disabled_direct_metadata(&mut turn_input);
let turn_input_len = turn_input.len();
let prompt = Prompt {
input: turn_input,
diff --git a/codex-rs/core/src/compact_remote_v2_attempt.rs b/codex-rs/core/src/compact_remote_v2_attempt.rs
index 1842d9f4a4..28e0f2d55e 100644
--- a/codex-rs/core/src/compact_remote_v2_attempt.rs
+++ b/codex-rs/core/src/compact_remote_v2_attempt.rs
@@ -72,6 +72,9 @@ pub(super) async fn run_remote_compact_v2_attempt(
.into_iter()
.map(|envelope| (envelope.item, envelope.metadata))
.unzip();
+ sess.services
+ .executed_tool_calls
+ .strip_disabled_direct_metadata(&mut input);
let tool_router = &step_context.tool_router;
input.push(ResponseItem::CompactionTrigger {});
let prompt = Prompt {
diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rs
index 953175a045..b319e75ddb 100644
--- a/codex-rs/core/src/compact_tests.rs
+++ b/codex-rs/core/src/compact_tests.rs
@@ -1,11 +1,157 @@
use super::*;
+use crate::session::tests::make_session_and_context_with_auth_and_config_and_rx;
+use codex_features::Feature;
use codex_history::CodexHarnessMetadata;
use codex_history::ResponseItemEnvelope;
+use codex_login::CodexAuth;
+use codex_model_provider_info::ModelProviderInfo;
use codex_protocol::ResponseItemId;
use codex_protocol::models::ContentItemKind;
use codex_protocol::models::DEFAULT_IMAGE_DETAIL;
+use codex_protocol::models::ExecutedToolCall;
+use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::InternalChatMessageMetadataPassthrough;
+use core_test_support::responses;
+use core_test_support::skip_if_no_network;
use pretty_assertions::assert_eq;
+use serde_json::json;
+use test_case::test_case;
+
+#[test_case(true; "metadata enabled")]
+#[test_case(false; "metadata disabled after capture")]
+#[tokio::test]
+async fn local_compaction_respects_tool_metadata_state(
+ metadata_enabled: bool,
+) -> anyhow::Result<()> {
+ skip_if_no_network!(Ok(()));
+ let server = responses::start_mock_server().await;
+ let provider = ModelProviderInfo::create_openai_provider(Some(format!("{}/v1", server.uri())));
+ let (session, turn, _events) = make_session_and_context_with_auth_and_config_and_rx(
+ CodexAuth::create_dummy_chatgpt_auth_for_testing(),
+ Vec::new(),
+ move |config| {
+ config.model = Some("gpt-5.2".to_string());
+ config.model_provider = provider;
+ config.model_provider.supports_websockets = false;
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("enable tool-call metadata");
+ },
+ )
+ .await;
+
+ let mut items = vec![user_message("Update the plan")];
+ for index in 0..5 {
+ 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);
+ items.push(ResponseItem::FunctionCall {
+ id: None,
+ name: "update_plan".to_string(),
+ namespace: None,
+ arguments: arguments.to_string(),
+ encrypted_function_args: None,
+ call_id: call_id.clone(),
+ internal_chat_message_metadata_passthrough: None,
+ });
+ let mut output = ResponseItem::FunctionCallOutput {
+ id: None,
+ call_id: Some(call_id),
+ name: None,
+ namespace: None,
+ output: FunctionCallOutputPayload::from_text("Plan updated".to_string()),
+ internal_chat_message_metadata_passthrough: Some(
+ InternalChatMessageMetadataPassthrough {
+ turn_id: Some("metadata-canary".to_string()),
+ create_time: Some(123.into()),
+ ..Default::default()
+ },
+ ),
+ };
+ output.append_executed_tool_calls(vec![ExecutedToolCall::new(
+ "update_plan".to_string(),
+ arguments,
+ )]);
+ output.mark_tool_calls_complete();
+ items.push(output);
+ }
+ session
+ .record_conversation_items(&turn, turn.model_info(), &items)
+ .await;
+ let live_history = session.clone_history().await;
+ let outputs = live_history
+ .raw_items()
+ .filter_map(|item| match item {
+ ResponseItem::FunctionCallOutput { .. } => Some(serde_json::to_value(item)),
+ _ => None,
+ })
+ .collect::<serde_json::Result<Vec<_>>>()?;
+ assert_eq!(outputs.len(), 5);
+ let metadata_bytes: usize = outputs
+ .iter()
+ .map(|item| {
+ serde_json::to_vec(&item["internal_chat_message_metadata_passthrough"])
+ .unwrap()
+ .len()
+ })
+ .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);
+
+ if !metadata_enabled {
+ let mut config = (*session.get_config().await).clone();
+ config.features.disable(Feature::ExecutedToolCallMetadata)?;
+ session.refresh_runtime_config(config).await;
+ }
+
+ let mock = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![
+ responses::ev_assistant_message("summary", "The prior calls finished."),
+ responses::ev_completed("compact-response"),
+ ]),
+ )
+ .await;
+ // OpenAI identity keeps the client from removing passthrough for compatibility.
+ run_compact_task(
+ Arc::clone(&session),
+ turn,
+ vec![UserInput::Text {
+ text: "Summarize the conversation.".to_string(),
+ text_elements: Vec::new(),
+ }],
+ )
+ .await?;
+
+ let request = mock.single_request();
+ assert!(request.inputs_of_type("compaction_trigger").is_empty());
+ for mut output in outputs {
+ let call_id = output["call_id"].as_str().expect("source call id");
+ let compact_output = request.function_call_output(call_id);
+ assert_eq!(compact_output["output"], json!("Plan updated"));
+ if !metadata_enabled {
+ let metadata = output["internal_chat_message_metadata_passthrough"]
+ .as_object_mut()
+ .expect("source metadata");
+ metadata.remove("executed_tool_calls");
+ metadata.remove("tool_calls_complete");
+ }
+ assert_eq!(
+ compact_output["internal_chat_message_metadata_passthrough"],
+ output["internal_chat_message_metadata_passthrough"]
+ );
+ }
+ let compacted_history = session.clone_history().await;
+ let expected_summary = format!("{SUMMARY_PREFIX}\nThe prior calls finished.");
+ assert!(compacted_history.raw_items().any(|item| {
+ matches!(item, ResponseItem::Message { role, content, .. }
+ if role == "user"
+ && content_items_to_text(content).as_deref() == Some(expected_summary.as_str()))
+ }));
+ Ok(())
+}
fn annotated(items: Vec<ResponseItem>) -> Vec<ResponseItemEnvelope> {
items.into_iter().map(ResponseItemEnvelope::new).collect()
diff --git a/codex-rs/core/src/context_manager/history_tests.rs b/codex-rs/core/src/context_manager/history_tests.rs
index 651ff3a8d7..c0f35668a9 100644
--- a/codex-rs/core/src/context_manager/history_tests.rs
+++ b/codex-rs/core/src/context_manager/history_tests.rs
@@ -2658,6 +2658,47 @@ fn non_base64_image_urls_use_image_estimates() {
);
}
+#[test]
+fn passthrough_metadata_does_not_change_context_estimates() {
+ for output in [
+ serde_json::json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": "hello"}]}),
+ serde_json::json!({"type": "function_call_output", "call_id": "call", "output": "result"}),
+ serde_json::json!({"type": "custom_tool_call_output", "call_id": "call", "output": "result"}),
+ serde_json::json!({"type": "tool_search_output", "call_id": "call", "execution": "client", "status": "completed", "tools": []}),
+ ] {
+ let original: ResponseItem = serde_json::from_value(output.clone()).expect("response item");
+ let before = estimate_response_item_model_visible_bytes(&original);
+ for turn_metadata in [
+ None,
+ Some(InternalChatMessageMetadataPassthrough::default()),
+ Some(InternalChatMessageMetadataPassthrough {
+ turn_id: Some("turn-\"你好\"".to_string()),
+ create_time: Some(123.into()),
+ ..unknown_content_metadata()
+ }),
+ ] {
+ let mut output = output.clone();
+ output["internal_chat_message_metadata_passthrough"] =
+ serde_json::to_value(turn_metadata).expect("turn metadata");
+ let mut item: ResponseItem = serde_json::from_value(output).expect("response item");
+ assert_eq!(estimate_response_item_model_visible_bytes(&item), before);
+ let mut call = codex_protocol::models::ExecutedToolCall::new(
+ "test_tool".to_string(),
+ serde_json::json!({"input": "x".repeat(8 * 1024)}),
+ );
+ call.set_tool_result_metadata(codex_protocol::models::ToolResultMetadata::new(
+ &serde_json::json!({"provider": "x".repeat(16 * 1024)}),
+ ));
+ item.append_executed_tool_calls(vec![call]);
+ item.set_tool_call_cell_id("cell");
+ item.mark_tool_calls_complete();
+ assert_eq!(estimate_response_item_model_visible_bytes(&item), before);
+ item.clear_internal_chat_message_metadata_passthrough();
+ assert_eq!(item, original);
+ }
+ }
+}
+
#[test]
fn encrypted_function_output_uses_plaintext_byte_estimate() {
let encrypted_content = "A".repeat(1_868);
diff --git a/codex-rs/core/src/stream_events_utils.rs b/codex-rs/core/src/stream_events_utils.rs
index b3c0a0a74f..3e3456e9ba 100644
--- a/codex-rs/core/src/stream_events_utils.rs
+++ b/codex-rs/core/src/stream_events_utils.rs
@@ -345,6 +345,10 @@ pub(crate) async fn handle_output_item_done(
}
// No tool call: convert messages/reasoning into turn items and mark them as complete.
Ok(None) => {
+ ctx.sess
+ .services
+ .executed_tool_calls
+ .observe_non_dispatched_call(&item);
let finalized_turn_item = finalize_non_tool_response_item(
ctx.sess.as_ref(),
TurnItemContributorPolicy::Run(ctx.turn_store.as_ref()),
@@ -381,6 +385,10 @@ pub(crate) async fn handle_output_item_done(
}
// The tool request should be answered directly (or was denied); push that response into the transcript.
Err(FunctionCallError::RespondToModel(message)) => {
+ ctx.sess
+ .services
+ .executed_tool_calls
+ .observe_non_dispatched_call(&item);
let response = ResponseInputItem::FunctionCallOutput {
call_id: String::new(),
output: FunctionCallOutputPayload {
diff --git a/codex-rs/core/src/stream_events_utils_tests.rs b/codex-rs/core/src/stream_events_utils_tests.rs
index 0a051970c3..2f5bc57072 100644
--- a/codex-rs/core/src/stream_events_utils_tests.rs
+++ b/codex-rs/core/src/stream_events_utils_tests.rs
@@ -6,14 +6,19 @@ use super::handle_non_tool_response_item;
use super::handle_output_item_done;
use super::last_assistant_message_from_item;
use super::response_item_may_include_external_context;
+use crate::session::session::Session;
use crate::session::step_context::StepContext;
use crate::session::tests::make_session_and_context;
+use crate::session::tests::make_session_and_context_with_auth_and_config_and_rx;
use crate::session::tests::tool_registry_for_test_step;
+use crate::session::turn_context::TurnContext;
use crate::tools::ToolRouter;
use crate::tools::parallel::ToolCallRuntime;
use crate::turn_diff_tracker::TurnDiffTracker;
use codex_extension_api::ExtensionData;
use codex_extension_api::TurnItemContributor;
+use codex_features::Feature;
+use codex_login::CodexAuth;
use codex_protocol::ResponseItemId;
use codex_protocol::items::AgentMessageContent;
use codex_protocol::items::TurnItem;
@@ -26,6 +31,7 @@ use codex_protocol::models::LocalShellStatus;
use codex_protocol::models::MessagePhase;
use codex_protocol::models::ResponseItem;
use pretty_assertions::assert_eq;
+use serde_json::json;
use std::sync::Arc;
use tokio_util::sync::CancellationToken;
@@ -279,14 +285,7 @@ async fn handle_non_tool_response_item_runs_turn_item_contributors_only_when_req
assert_eq!(text, "hello world");
}
-#[tokio::test]
-async fn handle_output_item_done_returns_contributed_last_agent_message() {
- let (mut session, turn_context) = make_session_and_context().await;
- let mut builder = codex_extension_api::ExtensionRegistryBuilder::new();
- builder.turn_item_contributor(Arc::new(RewriteAgentMessageContributor));
- session.services.extensions = Arc::new(builder.build());
- let session = Arc::new(session);
- let turn_context = Arc::new(turn_context);
+fn output_context(session: Arc<Session>, turn_context: Arc<TurnContext>) -> HandleOutputCtx {
let step_context = StepContext::for_test(Arc::clone(&turn_context));
let (registry, hosted_specs) = tool_registry_for_test_step(step_context.as_ref());
let router = Arc::new(ToolRouter::from_registry(
@@ -300,14 +299,23 @@ async fn handle_output_item_done_returns_contributed_last_agent_message() {
let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new()));
let tool_runtime =
ToolCallRuntime::new(Arc::clone(&session), Arc::clone(&step_context), tracker);
- let item = assistant_output_text("original assistant text");
- let mut ctx = HandleOutputCtx {
+ HandleOutputCtx {
sess: session,
step_context,
turn_store: Arc::new(ExtensionData::new(turn_context.sub_id.clone())),
tool_runtime,
cancellation_token: CancellationToken::new(),
- };
+ }
+}
+
+#[tokio::test]
+async fn handle_output_item_done_returns_contributed_last_agent_message() {
+ let (mut session, turn_context) = make_session_and_context().await;
+ let mut builder = codex_extension_api::ExtensionRegistryBuilder::new();
+ builder.turn_item_contributor(Arc::new(RewriteAgentMessageContributor));
+ session.services.extensions = Arc::new(builder.build());
+ let mut ctx = output_context(Arc::new(session), Arc::new(turn_context));
+ let item = assistant_output_text("original assistant text");
let output = handle_output_item_done(&mut ctx, item, /*previously_active_item*/ None)
.await
@@ -319,6 +327,126 @@ async fn handle_output_item_done_returns_contributed_last_agent_message() {
);
}
+#[tokio::test]
+async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
+ let (session, turn_context, _events) = make_session_and_context_with_auth_and_config_and_rx(
+ CodexAuth::from_api_key("Test API Key"),
+ Vec::new(),
+ |config| {
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("enable metadata");
+ config.update_plan_enabled = true;
+ },
+ )
+ .await;
+ let mut ctx = output_context(Arc::clone(&session), turn_context);
+ let mut pending = Vec::new();
+ for step in ["read", "write"] {
+ let arguments = json!({"plan": [{"step": step, "status": "in_progress"}]});
+ let call = serde_json::from_value(json!({
+ "type": "function_call", "call_id": "reused", "name": "update_plan",
+ "arguments": arguments.to_string(),
+ }))
+ .expect("direct input");
+ let result = handle_output_item_done(&mut ctx, call, /*previously_active_item*/ None)
+ .await
+ .expect("direct call should be handled");
+ assert!(result.needs_follow_up);
+ pending.push((
+ arguments,
+ result.tool_future.expect("dispatched direct call"),
+ ));
+ }
+
+ // Reapplying an enabled config keeps the same recording lifetime.
+ session
+ .refresh_runtime_config((*session.get_config().await).clone())
+ .await;
+ // Await in reverse order: each result must already own its record before history attachment.
+ let mut outputs = Vec::new();
+ for (arguments, future) in pending.into_iter().rev() {
+ let envelope = future.await.expect("plan result");
+ let item = &envelope.item;
+ let ResponseItem::FunctionCallOutput {
+ call_id: output_call_id,
+ output,
+ ..
+ } = item
+ else {
+ panic!("expected plan output");
+ };
+ assert_eq!(output_call_id.as_deref(), Some("reused"));
+ assert_eq!(output.text_content(), Some("Plan updated"));
+ let metadata = item
+ .executed_tool_call_metadata()
+ .expect("recorded direct call");
+ assert_eq!(metadata.tool_calls_complete, Some(true));
+ assert_eq!(
+ serde_json::to_value(&metadata.executed_tool_calls).expect("call metadata"),
+ json!([{
+ "name": "update_plan", "arguments": arguments,
+ }])
+ );
+ outputs.push(envelope.item);
+ }
+ let original = outputs.clone();
+ session
+ .services
+ .executed_tool_calls
+ .attach_to_prompt(&mut outputs, &mut Default::default());
+ assert_eq!(outputs, original);
+
+ let mut pending = Vec::new();
+ for call_id in ["disabled", "re-enabled"] {
+ let call = serde_json::from_value(json!({
+ "type": "function_call", "call_id": call_id, "name": "update_plan",
+ "arguments": "{\"plan\": []}",
+ }))
+ .expect("direct input");
+ pending.push(
+ handle_output_item_done(&mut ctx, call, /*previously_active_item*/ None)
+ .await
+ .expect("direct call should be handled")
+ .tool_future
+ .expect("dispatched direct call"),
+ );
+ }
+ let mut config = (*session.get_config().await).clone();
+ config
+ .features
+ .disable(Feature::ExecutedToolCallMetadata)
+ .expect("disable metadata");
+ session.refresh_runtime_config(config.clone()).await;
+ let result = pending
+ .remove(0)
+ .await
+ .expect("plan result after capture disabled");
+ assert!(result.item.executed_tool_call_metadata().is_none());
+ session
+ .services
+ .executed_tool_calls
+ .attach_to_prompt(&mut outputs, &mut Default::default());
+ let mut expected = original;
+ for item in &mut expected {
+ item.clear_executed_tool_calls();
+ }
+ assert_eq!(outputs, expected);
+
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("re-enable metadata");
+ session.refresh_runtime_config(config).await;
+ let result = pending
+ .pop()
+ .expect("call prepared before disable")
+ .await
+ .expect("plan result after capture re-enabled");
+ assert!(result.item.executed_tool_call_metadata().is_none());
+}
+
#[tokio::test]
async fn finalized_turn_item_defers_mailbox_for_contributed_visible_text() {
let (mut session, turn_context) = make_session_and_context().await;
diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rs
index bbbefeb741..9e046f12ee 100644
--- a/codex-rs/core/src/tools/executed_tool_calls.rs
+++ b/codex-rs/core/src/tools/executed_tool_calls.rs
@@ -1,6 +1,9 @@
//! Records attempted calls at existing execution boundaries. Request metadata policy
//! lives in the private request metadata module; this recorder must never dispatch or await tools.
+#[cfg(test)]
+#[path = "executed_tool_calls_direct_tests.rs"]
+mod direct_tests;
mod request_metadata;
use std::collections::HashMap;
@@ -8,6 +11,9 @@ use std::collections::HashSet;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::MutexGuard;
+use std::sync::Weak;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
use codex_code_mode::CellId;
use codex_features::Feature;
@@ -37,6 +43,10 @@ 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
+// budget because raw result metadata is intentionally not deserialized.
+const MAX_RETAINED_DIRECT_METADATA_BYTES: usize = 1024 * 1024;
type ExecutedToolCallCache =
HashMap<(std::mem::Discriminant<ResponseItem>, String), Vec<ExecutedToolCall>>;
@@ -46,11 +56,32 @@ type ExecutedToolCallCache =
#[derive(Clone, Default)]
pub(crate) struct ExecutedToolCalls {
state: Arc<Mutex<Option<ExecutedToolCallRecorderState>>>,
+ retained_direct_metadata_bytes: Arc<AtomicUsize>,
+ pending_direct_calls: Arc<AtomicUsize>,
+}
+
+// The tool future owns this reservation, so completion or cancellation releases it.
+pub(crate) struct DirectCallPermit {
+ recording: Weak<()>,
+ pending_direct_calls: Arc<AtomicUsize>,
+}
+
+impl DirectCallPermit {
+ pub(crate) fn strong_count(&self) -> usize {
+ self.recording.strong_count()
+ }
+}
+
+impl Drop for DirectCallPermit {
+ fn drop(&mut self) {
+ self.pending_direct_calls.fetch_sub(1, Ordering::Relaxed);
+ }
}
#[derive(Default)]
struct ExecutedToolCallRecorderState {
- direct_calls: HashMap<String, ExecutedToolCall>,
+ // Disabling drops this lifetime, permanently invalidating prepared Direct records.
+ recording: Arc<()>,
cells: HashMap<CellId, RecordedCell>,
output_cells: HashMap<String, CellId>,
retained_calls: HashMap<(std::mem::Discriminant<ResponseItem>, String), RetainedToolCalls>,
@@ -175,6 +206,8 @@ impl ExecutedToolCalls {
..Default::default()
}
}))),
+ retained_direct_metadata_bytes: Arc::new(AtomicUsize::new(0)),
+ pending_direct_calls: Arc::new(AtomicUsize::new(0)),
}
}
@@ -210,12 +243,105 @@ impl ExecutedToolCalls {
self.record_call(call, source, step_context.tool_router.tool_mode());
}
+ /// Keep a Direct record with its invocation so it can be attached to that invocation's output.
+ pub(crate) fn prepare_direct_call(
+ &self,
+ call: &ToolCall,
+ source: &ToolCallSource,
+ step_context: &StepContext,
+ ) -> Option<(ExecutedToolCall, DirectCallPermit)> {
+ if is_code_mode_wrapper(call, source, step_context.tool_router.tool_mode()) {
+ 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,
+ );
+ }
+ Some((recorded, permit))
+ }
+
+ fn reserve_direct_call(&self) -> Option<DirectCallPermit> {
+ let recording = Arc::downgrade(&self.lock_state().as_ref()?.recording);
+ self.pending_direct_calls
+ .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |pending| {
+ (pending < MAX_PENDING_EXECUTED_TOOL_CALLS).then_some(pending + 1)
+ })
+ .ok()?;
+ Some(DirectCallPermit {
+ recording,
+ pending_direct_calls: Arc::clone(&self.pending_direct_calls),
+ })
+ }
+
+ /// Validate the recording lifetime and attach together so a config refresh
+ /// cannot invalidate the call between those two operations.
+ pub(crate) fn attach_direct_call_to_output(
+ &self,
+ item: &mut ResponseItem,
+ prepared: Option<(ExecutedToolCall, DirectCallPermit)>,
+ ) {
+ let Some((call, permit)) = prepared else {
+ return;
+ };
+ let state = self.lock_state();
+ let Some(state) = state.as_ref() else {
+ return;
+ };
+ if !permit.recording.ptr_eq(&Arc::downgrade(&state.recording)) {
+ return;
+ }
+ let complete = matches!(call.arguments(), ExecutedToolCallArguments::Raw(_));
+ item.append_executed_tool_calls(vec![call]);
+ if complete {
+ item.mark_tool_calls_complete();
+ }
+ 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.clear_tool_result_metadata();
+ bytes = executed_tool_call_metadata_bytes(item);
+ }
+ if bytes > available {
+ item.clear_executed_tool_calls();
+ return;
+ }
+ // All Direct attachments share the recorder lock, including cloned handles.
+ self.retained_direct_metadata_bytes
+ .store(retained + bytes, Ordering::Relaxed);
+ }
+
+ /// Remember IDs from response items that bypass local tool dispatch.
+ pub(crate) fn observe_non_dispatched_call(&self, item: &ResponseItem) {
+ let Some(call_id) = input_call_id(item) else {
+ return;
+ };
+ let mut state = self.lock_state();
+ let Some(state) = state.as_mut() else {
+ return;
+ };
+ if !state.seen_ids.observe_call_id(call_id) {
+ state.invalidate_origin(call_id);
+ }
+ }
+
pub(crate) fn record_accepted_result(
&self,
source: &ToolCallSource,
call_id: &str,
result: &dyn ToolOutput,
) {
+ if !matches!(source, ToolCallSource::CodeMode { .. }) {
+ return;
+ }
// Release the lock before calling the output's trait method.
let recording = self.lock_state().is_some();
if recording && let Some(metadata) = result.tool_result_metadata() {
@@ -227,83 +353,25 @@ impl ExecutedToolCalls {
if self.lock_state().is_none() {
return;
}
- if matches!(source, ToolCallSource::Direct)
- && matches!(tool_mode, ToolMode::CodeMode | ToolMode::CodeModeOnly)
- && call.tool_name.is_default_namespace()
- && matches!(
- (call.tool_name.name.as_str(), &call.payload),
- (
- crate::tools::code_mode::PUBLIC_TOOL_NAME,
- ToolPayload::Custom { .. }
- ) | (
- crate::tools::code_mode::WAIT_TOOL_NAME,
- ToolPayload::Function { .. }
- )
- )
- {
- let mut state = self.lock_state();
- let Some(state) = state.as_mut() else {
- return;
- };
- let fresh = state.seen_ids.observe_call_id(&call.call_id);
- if !fresh {
- state.invalidate_origin(&call.call_id);
- }
- if fresh && state.pending_wrapper_origins.len() < MAX_PENDING_EXECUTED_TOOL_CALLS {
- state.pending_wrapper_origins.insert(call.call_id.clone());
- }
- return;
- }
-
- let original_bytes = match &call.payload {
- ToolPayload::Function { arguments } => arguments.len(),
- ToolPayload::Custom { input } => serialized_json_bytes(input).unwrap_or(usize::MAX),
- ToolPayload::ToolSearch { arguments } => {
- serialized_json_bytes(arguments).unwrap_or(usize::MAX)
- }
- };
- 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)
- };
match source {
ToolCallSource::Direct | ToolCallSource::DirectPlaintextMessage => {
let mut state = self.lock_state();
let Some(state) = state.as_mut() else {
return;
};
- if !state.seen_ids.observe_call_id(&call.call_id) {
+ let fresh = state.seen_ids.observe_call_id(&call.call_id);
+ if !fresh {
state.invalidate_origin(&call.call_id);
}
- if state.direct_calls.len() < MAX_PENDING_EXECUTED_TOOL_CALLS {
- state
- .direct_calls
- .entry(call.call_id.clone())
- .or_insert(recorded_call);
- } else if state.direct_calls.len() == MAX_PENDING_EXECUTED_TOOL_CALLS
- && !state.direct_calls.contains_key(&call.call_id)
+ if fresh
+ && is_code_mode_wrapper(call, source, tool_mode)
+ && state.pending_wrapper_origins.len() < MAX_PENDING_EXECUTED_TOOL_CALLS
{
- state.direct_calls.insert(
- call.call_id.clone(),
- ExecutedToolCall::truncated(
- recorded_call.name,
- original_bytes,
- /*max_bytes*/ 0,
- ),
- );
+ state.pending_wrapper_origins.insert(call.call_id.clone());
}
}
ToolCallSource::CodeMode { cell_id, .. } => {
+ let (recorded_call, original_bytes) = recorded_call(call);
self.record_nested_tool_call(
CellId::new(cell_id.clone()),
call.call_id.clone(),
@@ -376,28 +444,23 @@ impl ExecutedToolCalls {
call_id: &str,
metadata: &JsonValue,
) -> bool {
+ let ToolCallSource::CodeMode { cell_id, .. } = source else {
+ return false;
+ };
let metadata = codex_protocol::models::ToolResultMetadata::new(metadata);
let has_metadata = metadata.is_some();
let mut state = self.lock_state();
let Some(state) = state.as_mut() else {
return false;
};
- let call = match source {
- ToolCallSource::Direct | ToolCallSource::DirectPlaintextMessage => {
- state.direct_calls.get_mut(call_id)
- }
- ToolCallSource::CodeMode { cell_id, .. } => state
- .cells
- .get_mut(&CellId::new(cell_id.clone()))
- .and_then(|cell| cell.pending_calls.get_mut(call_id)),
- };
+ let call = state
+ .cells
+ .get_mut(&CellId::new(cell_id.clone()))
+ .and_then(|cell| cell.pending_calls.get_mut(call_id));
if let Some(call) = call {
call.set_tool_result_metadata(metadata);
return has_metadata;
}
- let ToolCallSource::CodeMode { cell_id, .. } = source else {
- return false;
- };
let Some((retained, index)) = state.retained_calls.values_mut().find_map(|retained| {
if retained.runtime_cell_id.as_ref()?.as_str() != cell_id.as_str() {
return None;
@@ -461,6 +524,47 @@ impl ExecutedToolCalls {
}
}
+fn is_code_mode_wrapper(call: &ToolCall, source: &ToolCallSource, tool_mode: ToolMode) -> bool {
+ matches!(source, ToolCallSource::Direct)
+ && matches!(tool_mode, ToolMode::CodeMode | ToolMode::CodeModeOnly)
+ && call.tool_name.is_default_namespace()
+ && matches!(
+ (call.tool_name.name.as_str(), &call.payload),
+ (
+ crate::tools::code_mode::PUBLIC_TOOL_NAME,
+ ToolPayload::Custom { .. }
+ ) | (
+ crate::tools::code_mode::WAIT_TOOL_NAME,
+ ToolPayload::Function { .. }
+ )
+ )
+}
+
+fn recorded_call(call: &ToolCall) -> (ExecutedToolCall, usize) {
+ let original_bytes = match &call.payload {
+ ToolPayload::Function { arguments } => arguments.len(),
+ ToolPayload::Custom { input } => serialized_json_bytes(input).unwrap_or(usize::MAX),
+ ToolPayload::ToolSearch { arguments } => {
+ serialized_json_bytes(arguments).unwrap_or(usize::MAX)
+ }
+ };
+ 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)
+ };
+ (recorded_call, original_bytes)
+}
+
fn input_call_id(item: &ResponseItem) -> Option<&str> {
match item {
ResponseItem::FunctionCall { call_id, .. }
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 7ebabace18..23697a019e 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
@@ -4,30 +4,43 @@
use super::*;
impl ExecutedToolCalls {
+ /// Compaction preserves captured records without applying the sampling request budget.
+ pub(crate) fn strip_disabled_direct_metadata(&self, items: &mut [ResponseItem]) {
+ if self.lock_state().is_none() {
+ clear_direct_call_metadata(items);
+ }
+ }
+
/// Attaches trusted completeness; request budgeting only revokes damaged inventories.
pub(crate) fn attach_to_prompt(
&self,
items: &mut [ResponseItem],
retry_cache: &mut ExecutedToolCallCache,
) {
- if self.attach_pending_to_prompt(items, retry_cache) {
+ let attached = {
+ let mut state = self.lock_state();
+ state
+ .as_mut()
+ .map(|state| Self::attach_pending_to_prompt_with_state(state, items, retry_cache))
+ };
+ let Some(attached) = attached else {
+ // Direct records now live in history; disabling capture also stops replaying them.
+ clear_direct_call_metadata(items);
+ return;
+ };
+ if attached || items.iter().any(has_direct_call_metadata) {
bound_executed_tool_calls_for_prompt(items);
}
}
- fn attach_pending_to_prompt(
- &self,
+ fn attach_pending_to_prompt_with_state(
+ state: &mut ExecutedToolCallRecorderState,
items: &mut [ResponseItem],
retry_cache: &mut ExecutedToolCallCache,
) -> bool {
- let mut state = self.lock_state();
- let Some(state) = state.as_mut() else {
- return false;
- };
// Failed wrappers have no callback; only their bounded bitmap observation survives.
state.pending_wrapper_origins.clear();
- if state.direct_calls.is_empty()
- && state.output_cells.is_empty()
+ if state.output_cells.is_empty()
&& state.retained_calls.is_empty()
&& retry_cache.is_empty()
{
@@ -62,13 +75,13 @@ impl ExecutedToolCalls {
.collect::<HashSet<_>>();
let mut attached = false;
for index in (0..items.len()).rev() {
- if state.direct_calls.is_empty()
- && state.output_cells.is_empty()
- && pending_outputs.is_empty()
- {
+ if state.output_cells.is_empty() && pending_outputs.is_empty() {
break;
}
let item = &items[index];
+ if has_direct_call_metadata(item) {
+ continue;
+ }
let Some(call_id) = output_call_id(item) else {
continue;
};
@@ -85,12 +98,7 @@ impl ExecutedToolCalls {
cached.clone()
} else {
let mut runtime_cell_id = None;
- let mut calls = state
- .direct_calls
- .remove(call_id)
- .into_iter()
- .collect::<Vec<_>>();
- let direct_call_collision = !calls.is_empty();
+ let mut calls = Vec::new();
let mut call_index_by_id = HashMap::new();
if let Some(output_cell_id) = state.output_cells.remove(call_id)
&& let Some(cell) = state.cells.get_mut(&output_cell_id)
@@ -127,7 +135,6 @@ impl ExecutedToolCalls {
}
cell.pending_full_argument_bytes = 0;
complete = cell.completion == CellCompletion::Complete
- && !direct_call_collision
&& (state.can_prove_wait_completion
|| matches!(item, ResponseItem::CustomToolCallOutput { .. }));
if matches!(
@@ -179,6 +186,9 @@ impl ExecutedToolCalls {
let mut invalid_cells = HashSet::new();
for index in 0..items.len() {
let item = &items[index];
+ if has_direct_call_metadata(item) {
+ continue;
+ }
let Some(call_id) = output_call_id(item) else {
continue;
};
@@ -232,6 +242,9 @@ impl ExecutedToolCalls {
}
}
for item in items.iter_mut() {
+ if has_direct_call_metadata(item) {
+ continue;
+ }
let Some(call_id) = output_call_id(item) else {
continue;
};
@@ -254,6 +267,9 @@ impl ExecutedToolCalls {
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;
};
@@ -305,6 +321,22 @@ impl ExecutedToolCalls {
}
}
+// Direct records already belong to their output; never rebuild them from the Code Mode cache.
+fn clear_direct_call_metadata(items: &mut [ResponseItem]) {
+ for item in items
+ .iter_mut()
+ .filter(|item| has_direct_call_metadata(item))
+ {
+ item.clear_executed_tool_calls();
+ }
+}
+
+fn has_direct_call_metadata(item: &ResponseItem) -> bool {
+ item.executed_tool_call_metadata().is_some_and(|metadata| {
+ metadata.cell_id.is_none() && metadata.executed_tool_calls.is_some()
+ })
+}
+
fn code_mode_input_matches_output(
input: &ResponseItem,
output: &ResponseItem,
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 2513022719..c7c6862ceb 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
@@ -10,6 +10,20 @@ use serde_json::json;
use super::*;
+impl ExecutedToolCalls {
+ fn attach_pending_to_prompt(
+ &self,
+ items: &mut [ResponseItem],
+ retry_cache: &mut ExecutedToolCallCache,
+ ) -> bool {
+ let mut state = self.lock_state();
+ let Some(state) = state.as_mut() else {
+ return false;
+ };
+ Self::attach_pending_to_prompt_with_state(state, items, retry_cache)
+ }
+}
+
fn new_recorder(history: InitialHistory) -> ExecutedToolCalls {
let mut features = Features::default();
features.enable(Feature::ExecutedToolCallMetadata);
@@ -66,6 +80,82 @@ fn tool_calls_complete(item: &ResponseItem) -> Option<bool> {
.and_then(|metadata| metadata.tool_calls_complete)
}
+#[test]
+fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
+ let recorder = new_recorder(InitialHistory::New);
+ let mut call = ExecutedToolCall::new("test_tool".to_string(), json!({"argument": "kept"}));
+ call.set_tool_result_metadata(ToolResultMetadata::new(&json!({
+ "provider": "x".repeat(1024),
+ })));
+ let mut first = output("first");
+ recorder.attach_direct_call_to_output(
+ &mut first,
+ Some((call.clone(), recorder.reserve_direct_call().unwrap())),
+ );
+ let full_bytes = executed_tool_call_metadata_bytes(&first);
+ assert!(full_bytes > 0);
+ assert_eq!(
+ recorder
+ .retained_direct_metadata_bytes
+ .load(Ordering::Relaxed),
+ full_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);
+ recorder.retained_direct_metadata_bytes.store(
+ MAX_RETAINED_DIRECT_METADATA_BYTES - call_bytes,
+ Ordering::Relaxed,
+ );
+ let mut second = output("second");
+ let result_before =
+ serde_json::to_value(&second).expect("serializable output")["output"].clone();
+ recorder.clone().attach_direct_call_to_output(
+ &mut second,
+ Some((call.clone(), recorder.reserve_direct_call().unwrap())),
+ );
+ let second_metadata = second
+ .executed_tool_call_metadata()
+ .expect("call remains when only its result metadata exceeds the budget");
+ assert_eq!(second_metadata.tool_calls_complete, Some(true));
+ assert_eq!(
+ second_metadata.executed_tool_calls.as_ref().map(Vec::len),
+ Some(1)
+ );
+ let serialized = serde_json::to_value(&second).expect("serializable output");
+ assert!(
+ serialized["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0]
+ .get("tool_result_metadata")
+ .is_none()
+ );
+ assert_eq!(serialized["output"], result_before);
+ assert_eq!(
+ recorder
+ .retained_direct_metadata_bytes
+ .load(Ordering::Relaxed),
+ MAX_RETAINED_DIRECT_METADATA_BYTES,
+ );
+
+ let mut features = Features::default();
+ recorder.refresh(&features);
+ features.enable(Feature::ExecutedToolCallMetadata);
+ recorder.refresh(&features);
+ let mut third = output("third");
+ recorder.attach_direct_call_to_output(
+ &mut third,
+ Some((call, recorder.reserve_direct_call().unwrap())),
+ );
+ assert!(third.executed_tool_call_metadata().is_none());
+ assert_eq!(
+ recorder
+ .retained_direct_metadata_bytes
+ .load(Ordering::Relaxed),
+ MAX_RETAINED_DIRECT_METADATA_BYTES,
+ );
+}
+
#[tokio::test]
async fn recorder_refreshes_without_changing_execution_features_or_claiming_missing_history() {
struct MetadataLookup<'a>(std::cell::Cell<usize>, JsonValue, &'a ExecutedToolCalls);
@@ -100,6 +190,7 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
assert!(calls.lock_state().is_none());
let mut next_config = (*session.get_config().await).clone();
let mut retry_cache = HashMap::new();
+ let mut prior_generation = None;
for (index, enabled) in [false, true, false, true].into_iter().enumerate() {
next_config
.features
@@ -124,51 +215,46 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
},
encrypted_function_args: None,
};
- calls.record_tool_call(&call, &ToolCallSource::Direct, &step);
- let result = MetadataLookup(std::cell::Cell::new(0), json!({}), &calls);
- calls.record_accepted_result(&ToolCallSource::Direct, &call.call_id, &result);
- assert_eq!(result.0.get(), usize::from(enabled));
-
- let input = serde_json::from_value(json!({
- "type": "function_call",
- "call_id": call.call_id,
- "name": "test_tool",
- "arguments": "{\"value\":7}",
- }))
- .expect("tool input must deserialize");
- let mut prompt = vec![input, output(&call.call_id)];
- if !enabled {
- prompt[1].mark_tool_calls_complete();
- }
- let original = prompt.clone();
- calls.attach_to_prompt(&mut prompt, &mut retry_cache);
- if !enabled {
- assert_eq!(prompt, original);
- } else {
- assert_eq!(tool_calls_complete(&prompt[1]), None);
+ let prepared = calls.prepare_direct_call(&call, &ToolCallSource::Direct, &step);
+ let expected = ExecutedToolCall::new("test_tool".to_string(), json!({"value": 7}));
+ assert_eq!(
+ prepared.as_ref().map(|(call, _)| call),
+ enabled.then_some(&expected)
+ );
+ if enabled {
+ if let Some(stale) = prior_generation.take() {
+ let mut stale_output = output("stale");
+ calls.attach_direct_call_to_output(&mut stale_output, Some(stale));
+ assert!(stale_output.executed_tool_call_metadata().is_none());
+ }
+ prior_generation = calls.prepare_direct_call(&call, &ToolCallSource::Direct, &step);
}
- let mut expected_call = ExecutedToolCall::new("test_tool".to_string(), json!({"value": 7}));
- expected_call.set_tool_result_metadata(ToolResultMetadata::new(&json!({})));
- let expected_calls = vec![expected_call];
+ let mut direct_output = output(&call.call_id);
+ calls.attach_direct_call_to_output(&mut direct_output, prepared);
assert_eq!(
- prompt[1]
+ direct_output
.executed_tool_call_metadata()
.and_then(|metadata| metadata.executed_tool_calls.as_ref()),
- enabled.then_some(&expected_calls),
+ enabled.then_some(&vec![expected]),
);
-
- if enabled {
- // Reapplying an enabled config must preserve already-recorded calls.
- session.refresh_runtime_config(next_config.clone()).await;
- let mut replay = original;
- calls.attach_to_prompt(&mut replay, &mut HashMap::new());
- assert_eq!(replay, prompt);
- }
+ assert_eq!(tool_calls_complete(&direct_output), enabled.then_some(true));
let cell = CellId::new(format!("cell-{index}"));
let origin = format!("exec-{index}");
calls.start_cell(&cell, &origin);
- let nested = record_nested_call(&calls, &cell, "nested");
+ let mut nested = record_nested_call(&calls, &cell, "nested");
+ let source = ToolCallSource::CodeMode {
+ cell_id: cell.as_str().to_string(),
+ runtime_tool_call_id: "runtime-nested".to_string(),
+ };
+ let result = MetadataLookup(std::cell::Cell::new(0), json!({}), &calls);
+ calls.record_accepted_result(&source, "nested", &result);
+ assert_eq!(result.0.get(), usize::from(enabled));
+ nested.set_tool_result_metadata(ToolResultMetadata::new(&json!({})));
+ if enabled {
+ // Reapplying an enabled config must preserve pending calls and their metadata.
+ session.refresh_runtime_config(next_config.clone()).await;
+ }
calls.finish_cell_recording(&cell);
let mut prompt = vec![exec_input(&origin), exec_output(&origin)];
calls.attach_to_prompt(&mut prompt, &mut retry_cache);
@@ -187,18 +273,6 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
let recorder = new_recorder(InitialHistory::Forked(Vec::new()));
for index in 0..MAX_PENDING_EXECUTED_TOOL_CALLS + 2 {
- recorder.record_call(
- &ToolCall {
- tool_name: codex_tools::ToolName::plain("direct_tool"),
- call_id: format!("direct-{index}"),
- payload: ToolPayload::Function {
- arguments: "{}".to_string(),
- },
- encrypted_function_args: None,
- },
- &ToolCallSource::Direct,
- ToolMode::Direct,
- );
recorder.record_call(
&ToolCall {
tool_name: codex_tools::ToolName::plain(crate::tools::code_mode::PUBLIC_TOOL_NAME),
@@ -212,8 +286,6 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
ToolMode::CodeMode,
);
}
- let metadata = json!({ "arbitrary-key": ["R1", null] });
- assert!(recorder.record_tool_result_metadata(&ToolCallSource::Direct, "direct-0", &metadata));
let cell_id = CellId::new("bounded-cell".to_string());
recorder.start_cell(&cell_id, "bounded-output");
@@ -236,32 +308,6 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
{
let state = recorder.lock_state();
let state = state.as_ref().unwrap();
- assert_eq!(
- state.direct_calls.len(),
- MAX_PENDING_EXECUTED_TOOL_CALLS + 1
- );
- assert_eq!(
- serde_json::to_value(state.direct_calls.get("direct-0").unwrap()).unwrap()["tool_result_metadata"],
- metadata,
- );
- assert_eq!(
- serde_json::to_value(
- state
- .direct_calls
- .get(&format!("direct-{MAX_PENDING_EXECUTED_TOOL_CALLS}"))
- .expect("first excess direct call must be marked"),
- )
- .expect("direct overflow marker must serialize"),
- json!({
- "name": "direct_tool",
- "arguments": {
- "_codex_executed_tool_call_truncated": {
- "original_bytes": 2,
- "max_bytes": 0,
- },
- },
- }),
- );
assert_eq!(
state.pending_nested_calls,
MAX_PENDING_EXECUTED_TOOL_CALLS + 1
@@ -341,26 +387,19 @@ fn executed_tool_call_recorder_bounds_retained_history_and_keeps_latest_calls()
for index in 0..512 {
let call_id = format!("retained-{index}");
- recorder.record_call(
- &ToolCall {
- tool_name: codex_tools::ToolName::plain(format!("retained_tool_{index}")),
- call_id: call_id.clone(),
- payload: ToolPayload::Function {
- arguments: arguments.clone(),
- },
- encrypted_function_args: None,
- },
- &ToolCallSource::Direct,
- ToolMode::Direct,
+ let cell_id = CellId::new(format!("retained-cell-{index}"));
+ recorder.start_cell(&cell_id, &call_id);
+ recorder.record_nested_tool_call(
+ cell_id.clone(),
+ format!("nested-{index}"),
+ ExecutedToolCall::new(
+ format!("retained_tool_{index}"),
+ json!({ "payload": "x".repeat(1024) }),
+ ),
+ arguments.len(),
);
- history.push(ResponseItem::FunctionCallOutput {
- id: None,
- call_id: Some(call_id),
- name: None,
- namespace: None,
- output: FunctionCallOutputPayload::from_text(String::new()),
- internal_chat_message_metadata_passthrough: None,
- });
+ 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);
@@ -756,6 +795,26 @@ fn completeness_rejects_reused_origin() {
assert_eq!(tool_calls_complete(&prompt[1]), None);
}
+#[test]
+fn malformed_search_id_cannot_prove_a_later_exec_complete() {
+ let recorder = new_recorder(InitialHistory::New);
+ let malformed_search = serde_json::from_value(json!({
+ "type": "tool_search_call", "call_id": "reused", "execution": "client",
+ "arguments": {"query": 42},
+ }))
+ .expect("tool search response item");
+ recorder.observe_non_dispatched_call(&malformed_search);
+
+ let cell = CellId::new("later-runtime".to_string());
+ recorder.start_cell(&cell, "reused");
+ record_nested_call(&recorder, &cell, "nested");
+ recorder.finish_cell_recording(&cell);
+ let mut prompt = [exec_input("reused"), exec_output("reused")];
+ recorder.attach_to_prompt(&mut prompt, &mut HashMap::new());
+ assert_eq!(tool_calls_complete(&prompt[1]), None);
+ assert!(prompt[1].executed_tool_call_metadata().is_some());
+}
+
#[test]
fn completeness_rejects_direct_id_collision_and_late_calls() {
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
new file mode 100644
index 0000000000..2e2a439afd
--- /dev/null
+++ b/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs
@@ -0,0 +1,123 @@
+//! Tests Direct metadata admission and permit lifetimes.
+//! Metadata limits must leave ordinary tool outputs unchanged.
+
+use codex_protocol::models::FunctionCallOutputPayload;
+use codex_protocol::models::ResponseInputItem;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+use super::*;
+
+fn output(call_id: &str) -> ResponseItem {
+ ResponseItem::from(ResponseInputItem::FunctionCallOutput {
+ call_id: call_id.to_string(),
+ output: FunctionCallOutputPayload::from_text("tool result".to_string()),
+ })
+}
+
+#[tokio::test]
+async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
+ let (_, turn) = crate::session::tests::make_session_and_context().await;
+ let step = StepContext::for_test(Arc::new(turn));
+ let mut features = Features::default();
+ features.enable(Feature::ExecutedToolCallMetadata);
+ let recorder = ExecutedToolCalls::new(&features, &InitialHistory::New);
+ let call = ToolCall {
+ tool_name: codex_tools::ToolName::plain("test_tool"),
+ call_id: "direct".to_string(),
+ payload: ToolPayload::Function {
+ arguments: json!({ "argument": "kept" }).to_string(),
+ },
+ encrypted_function_args: None,
+ };
+ let prepare = |recorder: &ExecutedToolCalls| {
+ recorder.prepare_direct_call(&call, &ToolCallSource::Direct, &step)
+ };
+ let mut pending = (0..MAX_PENDING_EXECUTED_TOOL_CALLS)
+ .map(|_| prepare(&recorder).expect("metadata slot"))
+ .collect::<Vec<_>>();
+ let cloned = recorder.clone();
+ let mut overflow = output("overflow");
+ let before = serde_json::to_value(&overflow).expect("serializable output");
+ cloned.attach_direct_call_to_output(&mut overflow, prepare(&cloned));
+ assert_eq!(
+ serde_json::to_value(&overflow).expect("serializable output"),
+ before,
+ );
+
+ let canceled = pending.pop().expect("pending call");
+ let unpolled = async move {
+ std::future::pending::<()>().await;
+ drop(canceled);
+ };
+ assert!(prepare(&cloned).is_none());
+ drop(unpolled);
+ let replacement = prepare(&cloned).expect("dropped future released its slot");
+ assert!(prepare(&recorder).is_none());
+
+ let mut completed = output("completed");
+ recorder.attach_direct_call_to_output(&mut completed, pending.pop());
+ assert_eq!(
+ completed
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.tool_calls_complete),
+ Some(true),
+ );
+ let after_completion = prepare(&recorder).expect("completion released its slot");
+
+ recorder.refresh(&Features::default());
+ recorder.refresh(&features);
+ assert!(prepare(&recorder).is_none());
+ let mut stale = output("stale");
+ recorder.attach_direct_call_to_output(&mut stale, Some(replacement));
+ assert!(stale.executed_tool_call_metadata().is_none());
+ let current = prepare(&recorder).expect("stale call released its slot");
+ let mut current_output = output("current");
+ recorder.attach_direct_call_to_output(&mut current_output, Some(current));
+ assert_eq!(
+ current_output
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.tool_calls_complete),
+ Some(true),
+ );
+ drop(pending);
+ drop(after_completion);
+ assert_eq!(recorder.pending_direct_calls.load(Ordering::Relaxed), 0);
+}
+
+#[tokio::test]
+async fn direct_budget_counts_the_encoded_argument_before_it_enters_history() {
+ let (_, turn) = crate::session::tests::make_session_and_context().await;
+ let step = StepContext::for_test(Arc::new(turn));
+ let mut features = Features::default();
+ features.enable(Feature::ExecutedToolCallMetadata);
+ 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);
+ let call = ToolCall {
+ tool_name: codex_tools::ToolName::plain("test_tool"),
+ call_id: "direct".to_string(),
+ payload: ToolPayload::Function {
+ arguments: invalid_json,
+ },
+ encrypted_function_args: None,
+ };
+ let mut item = output("direct");
+ let ordinary_output = serde_json::to_value(&item).unwrap()["output"].clone();
+ recorder.attach_direct_call_to_output(
+ &mut item,
+ recorder.prepare_direct_call(&call, &ToolCallSource::Direct, &step),
+ );
+ let wire = serde_json::to_value(&item).unwrap();
+ 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!(metadata.get("tool_calls_complete").is_none());
+}
diff --git a/codex-rs/core/src/tools/handlers/mcp.rs b/codex-rs/core/src/tools/handlers/mcp.rs
index 027f62f463..ced537f87c 100644
--- a/codex-rs/core/src/tools/handlers/mcp.rs
+++ b/codex-rs/core/src/tools/handlers/mcp.rs
@@ -748,7 +748,14 @@ mod tests {
})
);
- // Reuse the direct invocation to catch recording placed after the Code Mode-only return.
+ // Nested MCP result metadata still reaches the owning Code Mode cell.
+ let cell_id = codex_code_mode::CellId::new("mcp-cell".to_string());
+ recorder.start_cell(&cell_id, "exec-mcp-post");
+ let mut invocation = invocation;
+ invocation.source = ToolCallSource::CodeMode {
+ cell_id: cell_id.as_str().to_string(),
+ runtime_tool_call_id: "mcp-runtime-call".to_string(),
+ };
let mut output = output;
output.result.meta = Some(json!({ "provider/custom": { "items": [1, null] } }));
output.result_metadata_capture_allowed = true;
@@ -763,9 +770,10 @@ mod tests {
&invocation.step_context,
);
handler.on_tool_result_accepted(&invocation, &output);
- let mut items = [codex_protocol::models::ResponseItem::from(
- output.to_response_item(&invocation.call_id, &invocation.payload),
- )];
+ let mut items = [serde_json::from_value(json!({
+ "type": "custom_tool_call_output", "call_id": "exec-mcp-post", "output": "notes",
+ }))
+ .expect("Code Mode output")];
recorder.attach_to_prompt(&mut items, &mut Default::default());
assert_eq!(
serde_json::to_value(items[0].executed_tool_call_metadata()).unwrap()["executed_tool_calls"],
diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs
index 8cbc861b0f..c3bb77adc6 100644
--- a/codex-rs/core/src/tools/parallel.rs
+++ b/codex-rs/core/src/tools/parallel.rs
@@ -29,6 +29,7 @@ use crate::tools::router::ToolCallSource;
use codex_history::ResponseItemEnvelope;
use codex_protocol::error::CodexErr;
use codex_protocol::models::ResponseInputItem;
+use codex_protocol::models::ToolResultMetadata;
struct ToolCallTimingGuard {
started_at: Instant,
@@ -79,17 +80,31 @@ impl ToolCallRuntime {
) -> impl std::future::Future<Output = Result<ResponseItemEnvelope, CodexErr>> {
let error_call = call.clone();
let source = call.direct_source();
+ let recorder = self.session.services.executed_tool_calls.clone();
+ let recorded_call = recorder.prepare_direct_call(&call, &source, &self.step_context);
let step_context = Arc::clone(&self.step_context);
let future =
self.handle_tool_call_with_source(step_context, call, source, cancellation_token);
async move {
- match future.await {
- Ok(response) => Ok(response.into_response()),
- Err(FunctionCallError::Fatal(message)) => Err(CodexErr::Fatal(message)),
- Err(other) => Ok(ResponseItemEnvelope::new(
- Self::failure_response(error_call, other).into(),
- )),
- }
+ let result = future.await;
+ let mut recorded_call =
+ recorded_call.filter(|(_, recording)| recording.strong_count() > 0);
+ let mut response = match result {
+ Ok(result) => {
+ if let Some((call, _)) = recorded_call.as_mut()
+ && let Some(metadata) = result.result.tool_result_metadata()
+ {
+ call.set_tool_result_metadata(ToolResultMetadata::new(metadata));
+ }
+ result.into_response()
+ }
+ Err(FunctionCallError::Fatal(message)) => return Err(CodexErr::Fatal(message)),
+ Err(other) => {
+ ResponseItemEnvelope::new(Self::failure_response(error_call, other).into())
+ }
+ };
+ recorder.attach_direct_call_to_output(&mut response.item, recorded_call);
+ Ok(response)
}
}
diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs
index e4950170e0..b7a4c57fef 100644
--- a/codex-rs/core/tests/suite/code_mode.rs
+++ b/codex-rs/core/tests/suite/code_mode.rs
@@ -1620,21 +1620,26 @@ fn assert_result_metadata_call(
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-#[test_case(true, true, true, false, "[email protected]"; "copies_full_metadata_without_rules")]
-#[test_case(true, true, true, true, "[email protected]"; "accepted_error_keeps_metadata")]
-#[test_case(true, true, false, false, "[email protected]"; "missing_metadata_stays_absent")]
-#[test_case(false, true, true, false, "[email protected]"; "feature_off_does_not_record")]
-#[test_case(true, false, true, false, "[email protected]"; "extension_owned_apps_do_not_record")]
-#[test_case(true, true, true, false, "[email protected]"; "external_user_keeps_calls_without_metadata")]
-#[test_case(true, true, true, false, "[email protected]"; "lookalike_domain_does_not_record")]
-async fn code_mode_result_metadata_follows_call_binding(
+#[test_case(true, true, true, false, "[email protected]", ToolMode::CodeModeOnly; "copies_full_metadata_without_rules")]
+#[test_case(true, true, true, true, "[email protected]", ToolMode::CodeModeOnly; "accepted_error_keeps_metadata")]
+#[test_case(true, true, false, false, "[email protected]", ToolMode::CodeModeOnly; "missing_metadata_stays_absent")]
+#[test_case(false, true, true, false, "[email protected]", ToolMode::CodeModeOnly; "feature_off_does_not_record")]
+#[test_case(true, false, true, false, "[email protected]", ToolMode::CodeModeOnly; "extension_owned_apps_do_not_record")]
+#[test_case(true, true, true, false, "[email protected]", ToolMode::CodeModeOnly; "external_user_keeps_calls_without_metadata")]
+#[test_case(true, true, true, false, "[email protected]", ToolMode::CodeModeOnly; "lookalike_domain_does_not_record")]
+#[test_case(true, true, true, false, "[email protected]", ToolMode::Direct; "direct_keeps_metadata")]
+#[test_case(true, true, true, true, "[email protected]", ToolMode::Direct; "direct_accepted_error_keeps_metadata")]
+#[test_case(false, true, true, false, "[email protected]", ToolMode::Direct; "direct_feature_off_does_not_record")]
+async fn result_metadata_follows_call_binding(
metadata_enabled: bool,
host_owned: bool,
has_metadata: bool,
is_error: bool,
account_email: &str,
+ tool_mode: ToolMode,
) -> Result<()> {
skip_if_no_network!(Ok(()));
+ let direct = matches!(tool_mode, ToolMode::Direct);
let server = responses::start_mock_server().await;
let result_metadata = has_metadata.then(|| {
serde_json::json!({
@@ -1654,6 +1659,10 @@ async fn code_mode_result_metadata_follows_call_binding(
let mut builder =
result_metadata_apps_builder(apps_server.chatgpt_base_url.clone(), account_email)
.with_config(move |config| {
+ if direct {
+ config.features.disable(Feature::CodeMode).unwrap();
+ config.features.disable(Feature::CodeModeOnly).unwrap();
+ }
if !metadata_enabled {
config
.features
@@ -1677,43 +1686,87 @@ async fn code_mode_result_metadata_follows_call_binding(
builder = builder.with_extensions(Arc::new(extensions.build()));
}
let arguments = serde_json::json!({ "search": "launch plan" });
- let code = format!(
- "const tool = ALL_TOOLS.find(({{ name }}) => name.endsWith(\"{RESULT_METADATA_TOOL}\")); \
- const result = await tools[tool.name]({arguments}); \
- text(JSON.stringify({{ isError: Boolean(result.isError), hasMeta: Object.hasOwn(result, \"_meta\") }}));"
- );
- let (test, follow_up) =
- run_code_mode_turn_with_builder(&server, "Search a connected app", &code, builder).await?;
+ let (test, follow_up) = if direct {
+ let test = builder.build(&server).await?;
+ responses::mount_sse_once(
+ &server,
+ sse(vec![
+ responses::ev_function_call_with_namespace(
+ "call-1",
+ "mcp__codex_apps__messagesearch",
+ RESULT_METADATA_TOOL,
+ &arguments.to_string(),
+ ),
+ ev_completed("resp-1"),
+ ]),
+ )
+ .await;
+ let follow_up = responses::mount_sse_once(&server, sse(vec![ev_completed("resp-2")])).await;
+ test.submit_turn("Search a connected app").await?;
+ (test, follow_up)
+ } else {
+ let code = format!(
+ "const tool = ALL_TOOLS.find(({{ name }}) => name.endsWith(\"{RESULT_METADATA_TOOL}\")); \
+ const result = await tools[tool.name]({arguments}); \
+ text(JSON.stringify({{ isError: Boolean(result.isError), hasMeta: Object.hasOwn(result, \"_meta\") }}));"
+ );
+ run_code_mode_turn_with_builder(&server, "Search a connected app", &code, builder).await?
+ };
let request = follow_up.single_request();
assert_eq!(recorded_apps_tool_calls(&server).await.len(), 1);
- assert!(
- !request
- .body_json()
- .to_string()
- .contains(RESULT_METADATA_PRIVATE_RESULT)
- );
- 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!({ "isError": is_error, "hasMeta": false }),
- );
+ let output = if direct {
+ let output = request.function_call_output("call-1");
+ assert!(
+ output["output"]
+ .to_string()
+ .contains(RESULT_METADATA_PRIVATE_RESULT)
+ );
+ assert!(!output["output"].to_string().contains("provider_state"));
+ output
+ } else {
+ assert!(
+ !request
+ .body_json()
+ .to_string()
+ .contains(RESULT_METADATA_PRIVATE_RESULT)
+ );
+ 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!({ "isError": is_error, "hasMeta": false }),
+ );
+ request.custom_tool_call_output("call-1")
+ };
assert_eq!(
result_metadata_fixture_calls(&request.input()).count(),
usize::from(metadata_enabled),
);
- let output = request.custom_tool_call_output("call-1");
+ let captured = codex_core::test_support::history_with_tool_call_metadata(&test.codex).await;
+ if direct {
+ let result = captured
+ .iter()
+ .find_map(|item| match item {
+ codex_protocol::models::ResponseItem::FunctionCallOutput {
+ call_id,
+ output,
+ ..
+ } if call_id.as_deref() == Some("call-1") => Some(output),
+ _ => None,
+ })
+ .expect("captured direct output");
+ assert_eq!(result.success, Some(!is_error));
+ }
if metadata_enabled {
// The custom inference endpoint gets no raw metadata; inspect capture independently.
assert_result_metadata_call(&output, &arguments, /*expected_metadata*/ None);
- let captured = codex_core::test_support::history_with_tool_call_metadata(&test.codex).await;
let captured = serde_json::to_value(captured)?;
let captured_output = captured
.as_array()
.unwrap()
.iter()
- .find(|item| item["type"] == "custom_tool_call_output" && item["call_id"] == "call-1")
- .expect("captured exec output");
+ .find(|item| item["type"] == output["type"] && item["call_id"] == "call-1")
+ .expect("captured tool output");
// The public build never captures result metadata, even with employee test credentials.
let expected_metadata = None;
assert_result_metadata_call(captured_output, &arguments, expected_metadata);
diff --git a/codex-rs/core/tests/suite/direct_tool_metadata.rs b/codex-rs/core/tests/suite/direct_tool_metadata.rs
new file mode 100644
index 0000000000..9c3bffaf71
--- /dev/null
+++ b/codex-rs/core/tests/suite/direct_tool_metadata.rs
@@ -0,0 +1,357 @@
+//! Direct-call metadata coverage, including malformed calls and request-budget pruning.
+
+use anyhow::Result;
+use codex_features::Feature;
+use codex_model_provider::RemoteCompactionSupport;
+use codex_protocol::models::PermissionProfile;
+use codex_protocol::protocol::AskForApproval;
+use codex_protocol::protocol::EventMsg;
+use codex_protocol::protocol::Op;
+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;
+use core_test_support::responses::ev_function_call;
+use core_test_support::responses::ev_response_created;
+use core_test_support::responses::ev_tool_search_call;
+use core_test_support::responses::mount_sse_sequence;
+use core_test_support::responses::sse;
+use core_test_support::responses::start_mock_server;
+use core_test_support::skip_if_no_network;
+use core_test_support::test_codex::test_codex;
+use core_test_support::wait_for_event;
+use pretty_assertions::assert_eq;
+use serde_json::Value;
+use serde_json::json;
+use test_case::test_case;
+
+pub(super) fn tool_call_metadata(mut item: Value) -> Value {
+ let mut metadata = item["internal_chat_message_metadata_passthrough"].take();
+ let fields = metadata.as_object_mut().expect("output metadata");
+ fields.remove("turn_id");
+ fields.remove("create_time");
+ metadata
+}
+
+#[test_case(RemoteCompactionSupport::Unsupported, true; "local")]
+#[test_case(RemoteCompactionSupport::V2, true; "remote_v2")]
+#[test_case(RemoteCompactionSupport::V2, false; "remote_v2_disabled_after_capture")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn direct_call_metadata_during_compaction_respects_provider_support(
+ remote_compaction: RemoteCompactionSupport,
+ metadata_enabled: bool,
+) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ let server = start_mock_server().await;
+ let mut builder = test_codex().with_config(move |config| {
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("enable tool-call metadata");
+ config.update_plan_enabled = true;
+ if remote_compaction == RemoteCompactionSupport::Unsupported {
+ config.model_provider.name = "OpenAI-compatible test provider".to_string();
+ }
+ });
+ let test = builder.build_with_auto_env(&server).await?;
+ let seed_arguments = json!({"plan": [{"step": "read", "status": "in_progress"}]});
+ let arguments = json!({"plan": [{"step": "read", "status": "completed"}]});
+ let summary = "The prior call finished.";
+ let compact_output = match remote_compaction {
+ RemoteCompactionSupport::Unsupported => ev_assistant_message("summary", summary),
+ RemoteCompactionSupport::V2 => json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": summary},
+ }),
+ };
+ let mock = mount_sse_sequence(
+ &server,
+ vec![
+ sse(vec![
+ ev_function_call("shared", "update_plan", &seed_arguments.to_string()),
+ ev_completed("seed-call-response"),
+ ]),
+ sse(vec![
+ ev_assistant_message("seed", "done"),
+ ev_completed("seed-response"),
+ ]),
+ sse(vec![compact_output, ev_completed("compact-response")]),
+ sse(vec![
+ ev_function_call("shared", "update_plan", &arguments.to_string()),
+ ev_completed("reused-response"),
+ ]),
+ sse(vec![ev_completed("done")]),
+ ],
+ )
+ .await;
+ test.submit_turn("Update the plan before compaction")
+ .await?;
+ // Read the live history: deserializing a rollout intentionally drops host-owned metadata.
+ let history = test.codex.conversation_history_snapshot().await;
+ let history = serde_json::to_value(history.items().collect::<Vec<_>>())?;
+ let history = history.as_array().expect("source history");
+ let seed_output = history
+ .iter()
+ .find(|item| item["type"] == "function_call_output" && item["call_id"] == "shared")
+ .expect("direct output before compaction");
+ assert_eq!(seed_output["output"], "Plan updated");
+ assert_eq!(
+ tool_call_metadata(seed_output.clone()),
+ json!({
+ "executed_tool_calls": [{"name": "update_plan", "arguments": seed_arguments}],
+ "tool_calls_complete": true,
+ }),
+ );
+ let user_content = &history
+ .iter()
+ .find(|item| {
+ item["role"] == "user"
+ && item["content"][0]["text"] == "Update the plan before compaction"
+ })
+ .expect("source user message")["content"];
+ if !metadata_enabled {
+ let mut config = test.config.clone();
+ config.features.disable(Feature::ExecutedToolCallMetadata)?;
+ test.codex.refresh_runtime_config(config).await;
+ }
+ test.codex.submit(Op::Compact).await?;
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ let compacted = test.codex.conversation_history_snapshot().await;
+ let compacted = serde_json::to_value(compacted.items().collect::<Vec<_>>())?;
+ let compacted = compacted.as_array().expect("compacted history");
+ // Both paths retain the user message and summary, not the old call or output.
+ assert!(compacted.iter().all(|item| item["call_id"] != "shared"));
+ assert!(
+ compacted
+ .iter()
+ .any(|item| item["role"] == "user" && &item["content"] == user_content)
+ );
+ match remote_compaction {
+ RemoteCompactionSupport::Unsupported => assert!(compacted.iter().any(|item| {
+ item["role"] == "user"
+ && item["content"][0]["text"]
+ == format!("{}\n{summary}", codex_core::compact::SUMMARY_PREFIX)
+ })),
+ RemoteCompactionSupport::V2 => {
+ assert!(compacted.iter().any(|item| {
+ item["type"] == "compaction" && item["encrypted_content"] == summary
+ }))
+ }
+ }
+ test.submit_turn("Update the plan").await?;
+
+ let requests = mock.requests();
+ assert_eq!(requests.len(), 5);
+ let compact_request = &requests[2];
+ assert_eq!(
+ compact_request.inputs_of_type("compaction_trigger").len(),
+ usize::from(remote_compaction == RemoteCompactionSupport::V2),
+ );
+ let compact_output = compact_request.function_call_output("shared");
+ assert_eq!(compact_output["output"], seed_output["output"]);
+ // The local case uses a third-party provider; compact_tests.rs separately covers
+ // local compaction with an OpenAI provider that accepts passthrough metadata.
+ match remote_compaction {
+ RemoteCompactionSupport::Unsupported => assert!(
+ compact_output
+ .get("internal_chat_message_metadata_passthrough")
+ .is_none()
+ ),
+ RemoteCompactionSupport::V2 => {
+ let mut expected = seed_output["internal_chat_message_metadata_passthrough"].clone();
+ if !metadata_enabled {
+ let metadata = expected.as_object_mut().expect("source metadata");
+ metadata.remove("executed_tool_calls");
+ metadata.remove("tool_calls_complete");
+ }
+ assert_eq!(
+ compact_output["internal_chat_message_metadata_passthrough"],
+ expected
+ );
+ }
+ }
+ assert!(
+ requests[3]
+ .input()
+ .iter()
+ .all(|item| item["call_id"] != "shared")
+ );
+ let output = requests[4].function_call_output("shared");
+ assert_eq!(output["output"], "Plan updated");
+ let captured = test.codex.conversation_history_snapshot().await;
+ let captured = serde_json::to_value(captured.items().collect::<Vec<_>>())?;
+ let captured_output = captured
+ .as_array()
+ .expect("captured history")
+ .iter()
+ .find(|item| item["type"] == "function_call_output" && item["call_id"] == "shared")
+ .expect("captured direct output");
+ assert_eq!(
+ tool_call_metadata(captured_output.clone()),
+ if metadata_enabled {
+ json!({
+ "executed_tool_calls": [{"name": "update_plan", "arguments": arguments}],
+ "tool_calls_complete": true,
+ })
+ } else {
+ json!({})
+ },
+ );
+ Ok(())
+}
+
+#[test_case(false, 0; "metadata disabled")]
+#[test_case(true, 6; "request budget exceeded")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn direct_function_and_tool_search_mark_complete_attempts(
+ metadata_enabled: bool,
+ budget_calls: usize,
+) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let request_budget = 32 * 1024;
+ let server = start_mock_server().await;
+ let mut builder = test_codex().with_config(move |config| {
+ configure_search_capable_model(config);
+ config.update_plan_enabled = true;
+ if metadata_enabled {
+ let _ = config.features.enable(Feature::ExecutedToolCallMetadata);
+ } else {
+ let _ = config.features.disable(Feature::ExecutedToolCallMetadata);
+ }
+ });
+ let test = builder.build_with_auto_env(&server).await?;
+ let valid_arguments = json!({"plan": [{"step": "read", "status": "in_progress"}]});
+ let malformed_arguments = "{malformed";
+ let search_arguments = json!({"query": "nonexistent-completeness-proof-tool", "limit": null});
+ // The bulk calls fit the per-call limit; their combined metadata forces pruning.
+ let budget_arguments =
+ json!({"plan": [{"step": "x".repeat(7 * 1024), "status": "in_progress"}]});
+ let budget_arguments_json = budget_arguments.to_string();
+ assert!(budget_arguments_json.len() < 8 * 1024);
+ if budget_calls > 0 {
+ assert!(budget_calls * budget_arguments_json.len() > request_budget);
+ }
+ let mut events = vec![ev_response_created("resp-1")];
+ if budget_calls > 0 {
+ events.push(ev_function_call(
+ "plan-oversized",
+ "update_plan",
+ &json!({"plan": [{"step": "x".repeat(9 * 1024), "status": "in_progress"}]}).to_string(),
+ ));
+ }
+ for index in 0..budget_calls {
+ events.push(ev_function_call(
+ &format!("plan-budget-{index}"),
+ "update_plan",
+ &budget_arguments_json,
+ ));
+ }
+ events.extend([
+ ev_function_call("plan-valid", "update_plan", &valid_arguments.to_string()),
+ ev_function_call("plan-malformed", "update_plan", malformed_arguments),
+ ev_tool_search_call("search", &search_arguments),
+ ev_completed("resp-1"),
+ ]);
+ let mock = mount_sse_sequence(
+ &server,
+ vec![
+ sse(events),
+ sse(vec![
+ ev_assistant_message("msg-1", "done"),
+ ev_completed("resp-2"),
+ ]),
+ ],
+ )
+ .await;
+ test.submit_turn_with_approval_and_permission_profile(
+ "exercise direct attempts",
+ AskForApproval::Never,
+ PermissionProfile::Disabled,
+ )
+ .await?;
+
+ let requests = mock.requests();
+ assert_eq!(requests.len(), 2);
+ let request = &requests[1];
+ let valid_output = request.function_call_output("plan-valid");
+ let malformed_output = request.function_call_output("plan-malformed");
+ let search_output = request.tool_search_output("search");
+ assert_eq!(valid_output["output"], json!("Plan updated"));
+ assert!(
+ malformed_output["output"]
+ .as_str()
+ .expect("parse error output")
+ .starts_with("failed to parse function arguments:"),
+ );
+ assert_eq!(search_output["execution"], json!("client"));
+
+ let mut metadata_bytes = 0;
+ for (output, name, arguments) in [
+ (valid_output, "update_plan", valid_arguments),
+ (malformed_output, "update_plan", json!(malformed_arguments)),
+ (
+ search_output,
+ "tool_search",
+ json!({"query": "nonexistent-completeness-proof-tool"}),
+ ),
+ ] {
+ let expected = if metadata_enabled {
+ json!({
+ "executed_tool_calls": [{"name": name, "arguments": arguments}],
+ "tool_calls_complete": true,
+ })
+ } else {
+ json!({})
+ };
+ let metadata = tool_call_metadata(output);
+ metadata_bytes += serde_json::to_vec(&metadata)?.len();
+ assert_eq!(metadata, expected);
+ }
+ if budget_calls > 0 {
+ let output = request.function_call_output("plan-oversized");
+ 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!(metadata.get("tool_calls_complete").is_none());
+ }
+ let mut truncated = 0;
+ for index in 0..budget_calls {
+ let output = request.function_call_output(&format!("plan-budget-{index}"));
+ assert_eq!(output["output"], json!("Plan updated"));
+ let metadata = tool_call_metadata(output);
+ metadata_bytes += serde_json::to_vec(&metadata)?.len();
+ let calls = metadata["executed_tool_calls"]
+ .as_array()
+ .expect("recorded calls");
+ assert_eq!(calls.len(), 1);
+ if calls[0]["arguments"]
+ .get("_codex_executed_tool_call_truncated")
+ .is_some()
+ {
+ truncated += 1;
+ assert!(metadata.get("tool_calls_complete").is_none());
+ } else {
+ assert_eq!(
+ metadata,
+ json!({
+ "executed_tool_calls": [{"name": "update_plan", "arguments": budget_arguments}],
+ "tool_calls_complete": true,
+ })
+ );
+ }
+ }
+ assert!(metadata_bytes <= request_budget);
+ assert!(
+ budget_calls == 0 || truncated > 0,
+ "request must exercise pruning"
+ );
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rs
index 39325ce757..0d25e5375d 100644
--- a/codex-rs/core/tests/suite/guardian_review.rs
+++ b/codex-rs/core/tests/suite/guardian_review.rs
@@ -300,7 +300,7 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
skip_if_no_network!(Ok(()));
skip_if_wine_exec!(
Ok(()),
- "Guardian approval actions require host-native paths"
+ "approved commands can collide on process IDs in the shared Wine exec server"
);
let server = start_mock_server().await;
@@ -440,6 +440,127 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
Ok(())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[test_case(false; "legacy_transcript")]
+#[test_case(true; "thread_owned_transcript")]
+async fn guardian_requests_record_only_their_own_tool_calls(thread_owned: bool) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ skip_if_wine_exec!(
+ Ok(()),
+ "basic PowerShell execution through Wine exec is not passing yet"
+ );
+
+ let server = start_mock_server().await;
+ let mut builder = test_codex().with_config(move |config| {
+ config
+ .features
+ .set_enabled(Feature::GuardianThreadContext, thread_owned)
+ .expect("configure Guardian context mode");
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("enable tool-call metadata");
+ config.update_plan_enabled = true;
+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;
+ });
+ let test = builder.build_with_auto_env(&server).await?;
+ let plan_args = json!({"plan": [{"step": "inspect", "status": "completed"}]});
+ let guardian_tool_args = json!({
+ "cmd": "printf guardian-metadata-own-call",
+ "login": false,
+ "yield_time_ms": 1000,
+ });
+ let responses = mount_sse_sequence(
+ &server,
+ vec![
+ sse(vec![
+ ev_function_call("plan", "update_plan", &plan_args.to_string()),
+ ev_completed("parent-plan"),
+ ]),
+ sse(vec![
+ ev_function_call(
+ "reviewed-command",
+ "exec_command",
+ r#"{"cmd":"true","sandbox_permissions":"require_escalated","justification":"Exercise Guardian metadata filtering."}"#,
+ ),
+ ev_completed("parent-review"),
+ ]),
+ sse(vec![
+ ev_function_call(
+ "guardian-command",
+ "exec_command",
+ &guardian_tool_args.to_string(),
+ ),
+ ev_completed("guardian-command-response"),
+ ]),
+ sse(vec![
+ ev_assistant_message(
+ "guardian-denial",
+ r#"{"risk_level":"high","user_authorization":"low","outcome":"deny","rationale":"The test denies escalation."}"#,
+ ),
+ ev_completed("guardian-review"),
+ ]),
+ sse(vec![ev_completed("parent-done")]),
+ ],
+ )
+ .await;
+
+ test.submit_text_turn("Update the plan, then request a reviewed command")
+ .await?;
+
+ let expected_calls = json!([{"name": "update_plan", "arguments": plan_args}]);
+ let requests = responses.requests();
+ assert_eq!(requests.len(), 5);
+ let parent_output = requests[1].function_call_output("plan");
+ assert_eq!(parent_output["output"], "Plan updated");
+ assert_eq!(
+ parent_output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"],
+ expected_calls,
+ );
+ assert_eq!(
+ parent_output["internal_chat_message_metadata_passthrough"]["tool_calls_complete"],
+ true,
+ );
+ let guardian_output = requests[3].function_call_output("guardian-command");
+ let guardian_text = guardian_output["output"].as_str().expect("command output");
+ assert!(
+ guardian_text.contains("Process exited with code 0"),
+ "Guardian command did not complete successfully: {guardian_text}"
+ );
+ assert!(
+ guardian_text.ends_with("guardian-metadata-own-call"),
+ "Guardian command returned unexpected output: {guardian_text}"
+ );
+ assert_eq!(
+ super::direct_tool_metadata::tool_call_metadata(guardian_output),
+ json!({
+ "executed_tool_calls": [{"name": "exec_command", "arguments": guardian_tool_args}],
+ "tool_calls_complete": true,
+ }),
+ );
+ for guardian_request in &requests[2..4] {
+ assert_eq!(
+ guardian_request.body_json()["client_metadata"]["x-openai-subagent"],
+ "guardian",
+ );
+ assert!(guardian_request.body_contains_text("Plan updated"));
+ for item in guardian_request.input() {
+ if item["type"] == "function_call_output" && item["call_id"] == "guardian-command" {
+ continue;
+ }
+ let metadata = &item["internal_chat_message_metadata_passthrough"];
+ for field in ["executed_tool_calls", "tool_calls_complete", "cell_id"] {
+ assert!(
+ metadata.get(field).is_none(),
+ "Guardian reattributed parent {field} to an unrelated input item"
+ );
+ }
+ }
+ }
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[test_case(CodexAuth::from_api_key("test-api-key"), true, "gpt-5.6-luna"; "api_key_uses_luna_with_responses_lite")]
#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), true, "codex-auto-review"; "chatgpt_uses_codex_auto_review")]
@@ -2214,10 +2335,6 @@ printf '%s\n' "${@: -1}" >> "${payload_path}""#,
async fn yielded_code_mode_denials_interrupt_the_servicing_turn() -> Result<()> {
skip_if_no_network!(Ok(()));
skip_if_sandbox!(Ok(()));
- skip_if_wine_exec!(
- Ok(()),
- "Guardian approval actions require host-native paths"
- );
let server = start_mock_server().await;
let mut builder = test_codex()
diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rs
index 1ef839af96..e757b5a8b9 100644
--- a/codex-rs/core/tests/suite/mod.rs
+++ b/codex-rs/core/tests/suite/mod.rs
@@ -64,6 +64,7 @@ mod cyber_access_program;
mod cyber_exec_policy;
mod daybreak_access;
mod deprecation_notice;
+mod direct_tool_metadata;
mod exec;
mod exec_policy;
#[cfg(not(target_os = "windows"))]
diff --git a/codex-rs/core/tests/suite/subagent_notifications.rs b/codex-rs/core/tests/suite/subagent_notifications.rs
index 052431b3e0..ac5e47f16c 100644
--- a/codex-rs/core/tests/suite/subagent_notifications.rs
+++ b/codex-rs/core/tests/suite/subagent_notifications.rs
@@ -73,6 +73,8 @@ use wiremock::MockServer;
use wiremock::matchers::method;
use wiremock::matchers::path;
+use super::direct_tool_metadata::tool_call_metadata;
+
const SPAWN_CALL_ID: &str = "spawn-call-1";
const MULTI_AGENT_V1_NAMESPACE: &str = "multi_agent_v1";
const MULTI_AGENT_V2_NAMESPACE: &str = "collaboration";
@@ -2235,16 +2237,24 @@ async fn multi_agent_v2_spawn_sends_agent_message_to_child(
} else {
"koffing"
};
- let mut builder = test_codex().with_model(parent_model).with_config(|config| {
- config
- .features
- .enable(Feature::Collab)
- .expect("test config should allow feature update");
- config
- .features
- .enable(Feature::MultiAgentV2)
- .expect("test config should allow feature update");
- });
+ let mut builder = test_codex()
+ .with_model(parent_model)
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::Collab)
+ .expect("test config should allow feature update");
+ config
+ .features
+ .enable(Feature::MultiAgentV2)
+ .expect("test config should allow feature update");
+ if plaintext {
+ config
+ .features
+ .enable(Feature::ExecutedToolCallMetadata)
+ .expect("enable tool-call metadata");
+ }
+ });
let test = builder.build(&server).await?;
let root_thread_id = test.session_configured.thread_id;
@@ -2307,15 +2317,33 @@ async fn multi_agent_v2_spawn_sends_agent_message_to_child(
);
}
if plaintext {
+ let parent_request = parent_request_log
+ .requests()
+ .into_iter()
+ .find(|request| {
+ request
+ .inputs_of_type("function_call_output")
+ .iter()
+ .any(|item| item["call_id"] == SPAWN_CALL_ID)
+ })
+ .expect("parent request with spawn result");
assert!(
- parent_request_log.requests().into_iter().any(|request| {
- request.input().iter().any(|item| {
- item["call_id"].as_str() == Some(SPAWN_CALL_ID)
- && item["encrypted_function_args"] == json!([])
- })
+ parent_request.input().iter().any(|item| {
+ item["call_id"].as_str() == Some(SPAWN_CALL_ID)
+ && item["encrypted_function_args"] == json!([])
}),
"plaintext function-call metadata should survive replay"
);
+ assert_eq!(
+ tool_call_metadata(parent_request.function_call_output(SPAWN_CALL_ID)),
+ json!({
+ "executed_tool_calls": [{
+ "name": "collaboration__spawn_agent",
+ "arguments": serde_json::from_str::<Value>(&spawn_args)?,
+ }],
+ "tool_calls_complete": true,
+ }),
+ );
}
let child_thread_id = test
diff --git a/codex-rs/core/tests/suite/tools.rs b/codex-rs/core/tests/suite/tools.rs
index 5afee5f17b..1624e777fd 100644
--- a/codex-rs/core/tests/suite/tools.rs
+++ b/codex-rs/core/tests/suite/tools.rs
@@ -51,6 +51,8 @@ use serde_json::json;
use test_case::test_case;
use wiremock::ResponseTemplate;
+use super::direct_tool_metadata::tool_call_metadata;
+
fn tool_names(body: &Value) -> Vec<String> {
body.get("tools")
.and_then(Value::as_array)
@@ -448,6 +450,7 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
"name": format!("{namespace}__{tool_name}"),
"arguments": input,
}],
+ "tool_calls_complete": true,
},
}),
)
@@ -484,12 +487,14 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
.await?;
let escaped_request = escaped_mock.single_request();
assert_eq!(
- escaped_request.custom_tool_call_output(call_id)["internal_chat_message_metadata_passthrough"]
- ["executed_tool_calls"],
- json!([{
- "name": format!("{namespace}__{tool_name}"),
- "arguments": input,
- }]),
+ tool_call_metadata(escaped_request.custom_tool_call_output(call_id)),
+ json!({
+ "executed_tool_calls": [{
+ "name": format!("{namespace}__{tool_name}"),
+ "arguments": input,
+ }],
+ "tool_calls_complete": true,
+ }),
);
let expected_escaped_calls = json!([{
"name": format!("{namespace}__{tool_name}"),
@@ -501,9 +506,8 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
},
}]);
assert_eq!(
- escaped_request.custom_tool_call_output(escaped_call_id)["internal_chat_message_metadata_passthrough"]
- ["executed_tool_calls"],
- expected_escaped_calls,
+ tool_call_metadata(escaped_request.custom_tool_call_output(escaped_call_id)),
+ json!({"executed_tool_calls": expected_escaped_calls}),
);
let direct_exec_call_id = "custom-direct-exec";
@@ -538,17 +542,12 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
let direct_exec_request = direct_exec_mock.single_request();
assert_eq!(
- direct_exec_request.custom_tool_call_output(call_id)["internal_chat_message_metadata_passthrough"]
- ["executed_tool_calls"],
- json!([{
- "name": format!("{namespace}__{tool_name}"),
- "arguments": input,
- }]),
+ tool_call_metadata(direct_exec_request.custom_tool_call_output(call_id)),
+ tool_call_metadata(escaped_request.custom_tool_call_output(call_id)),
);
assert_eq!(
- direct_exec_request.custom_tool_call_output(escaped_call_id)["internal_chat_message_metadata_passthrough"]
- ["executed_tool_calls"],
- expected_escaped_calls,
+ tool_call_metadata(direct_exec_request.custom_tool_call_output(escaped_call_id)),
+ tool_call_metadata(escaped_request.custom_tool_call_output(escaped_call_id)),
);
let direct_exec_output = direct_exec_request.custom_tool_call_output(direct_exec_call_id);
assert_eq!(
@@ -556,11 +555,14 @@ async fn namespaced_custom_tool_call_preserves_namespace_through_dispatch_and_re
json!("unsupported custom tool call: exec"),
);
assert_eq!(
- direct_exec_output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"],
- json!([{
- "name": codex_code_mode::PUBLIC_TOOL_NAME,
- "arguments": input,
- }]),
+ tool_call_metadata(direct_exec_output),
+ json!({
+ "executed_tool_calls": [{
+ "name": codex_code_mode::PUBLIC_TOOL_NAME,
+ "arguments": input,
+ }],
+ "tool_calls_complete": true,
+ }),
);
Ok(())
diff --git a/codex-rs/guardian-context/src/history.rs b/codex-rs/guardian-context/src/history.rs
index 7eef8d6743..9500948e62 100644
--- a/codex-rs/guardian-context/src/history.rs
+++ b/codex-rs/guardian-context/src/history.rs
@@ -14,6 +14,7 @@ use std::sync::Arc;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
+use codex_protocol::models::executed_tool_call_metadata_bytes;
use crate::SectionHistory;
@@ -52,8 +53,10 @@ impl TranscriptHistory {
/// Non-user overflow removes at least half the existing entries; byte limits may need more.
/// Oversized user images fall back to bounded text; other oversized items are skipped.
pub fn record(&mut self, item: &ResponseItem) {
+ let metadata_bytes = executed_tool_call_metadata_bytes(item);
let mut size = BoundedSize {
bytes: std::mem::size_of::<ResponseItem>(),
+ max_bytes: MAX_BYTES_PER_KIND.saturating_add(metadata_bytes),
};
let measured = serde_json::to_writer(&mut size, item).and_then(|()| {
// ResponseItem serialization can omit reasoning content that cloning retains.
@@ -111,6 +114,8 @@ impl TranscriptHistory {
}
return;
}
+ // Analytics must not change which evidence fits Guardian's retention budget.
+ size.bytes = size.bytes.saturating_sub(metadata_bytes);
let is_user = item.is_user_message();
let (mut count, mut bytes) = self
.items
@@ -178,11 +183,12 @@ impl SectionHistory for TranscriptHistory {
// Count without allocating a serialized copy, and stop before cloning an oversized item.
struct BoundedSize {
bytes: usize,
+ max_bytes: usize,
}
impl Write for BoundedSize {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
- if bytes.len() > MAX_BYTES_PER_KIND.saturating_sub(self.bytes) {
+ if bytes.len() > self.max_bytes.saturating_sub(self.bytes) {
return Err(io::Error::other(
"review history item exceeds storage budget",
));
diff --git a/codex-rs/guardian-context/src/history_tests.rs b/codex-rs/guardian-context/src/history_tests.rs
index 1d6dc4653d..4c03904ba2 100644
--- a/codex-rs/guardian-context/src/history_tests.rs
+++ b/codex-rs/guardian-context/src/history_tests.rs
@@ -1,3 +1,4 @@
+use codex_protocol::models::ExecutedToolCall;
use codex_protocol::models::ReasoningItemContent;
use pretty_assertions::assert_eq;
use serde_json::json;
@@ -91,6 +92,40 @@ fn byte_limits_are_independent_and_oversized_items_do_not_clear_history() {
assert_eq!(history.items().collect::<Vec<_>>(), vec![&keep, &large]);
}
+#[test]
+fn tool_metadata_is_retained_without_changing_retention_size() {
+ let before = tool("keep this");
+ let mut plain = tool(&"x".repeat(MAX_BYTES_PER_KIND - 4096));
+ plain.set_turn_id_if_missing("turn-1");
+ let mut recorded = plain.clone();
+ recorded.append_executed_tool_calls(vec![ExecutedToolCall::new(
+ "command".to_string(),
+ json!({"command": "x".repeat(7000)}),
+ )]);
+ recorded.mark_tool_calls_complete();
+ let mut baseline = TranscriptHistory::default();
+ let mut with_metadata = TranscriptHistory::default();
+ baseline.reset([&before, &plain]);
+ with_metadata.reset([&before, &recorded]);
+ assert_eq!(
+ with_metadata.items().collect::<Vec<_>>(),
+ vec![&before, &recorded]
+ );
+ assert_eq!(
+ with_metadata
+ .items
+ .iter()
+ .map(|(_, size)| *size)
+ .collect::<Vec<_>>(),
+ baseline
+ .items
+ .iter()
+ .map(|(_, size)| *size)
+ .collect::<Vec<_>>()
+ );
+ assert_eq!(with_metadata.generation(), baseline.generation());
+}
+
#[test]
fn oversized_user_images_preserve_text_and_metadata_in_order() {
let before = tool("earlier tool result");
diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rs
index faff4b9824..7286f9865f 100644
--- a/codex-rs/protocol/src/models.rs
+++ b/codex-rs/protocol/src/models.rs
@@ -961,7 +961,8 @@ pub struct InternalChatMessageMetadataPassthrough {
#[schemars(skip)]
#[ts(skip)]
pub content_item_kinds: Option<Vec<ContentItemKind>>,
- // Ignore input values so requests cannot fake tool call records.
+ // Ignore input values so requests and rollout reloads cannot fake tool call records.
+ // A resumed thread can record new calls, but cannot prove old calls from this payload.
/// Host-owned Code Mode cell shared by its `exec` and subsequent `wait` outputs.
#[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]
#[schemars(skip)]
@@ -972,8 +973,9 @@ pub struct InternalChatMessageMetadataPassthrough {
#[schemars(skip)]
#[ts(skip)]
pub executed_tool_calls: Option<Vec<ExecutedToolCall>>,
- /// Whether the host finished recording this cell's calls without losing calls or arguments.
- /// This describes the call inventory across the cell's outputs, not tool success.
+ /// Whether the host recorded the complete call inventory without losing calls or arguments.
+ /// For a direct tool output this covers its single invocation; with `cell_id`, it covers
+ /// the Code Mode cell across its outputs. Neither case describes tool success.
#[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]
#[schemars(skip)]
#[ts(skip)]
diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rs
index ffca9bbfb5..f690fe3585 100644
--- a/codex-rs/protocol/src/models/executed_tool_calls.rs
+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs
@@ -463,7 +463,7 @@ impl ResponseItem {
.extend(calls);
}
- /// Marks a host-owned cell's recorded tool calls as complete.
+ /// Marks a host-owned direct invocation or Code Mode cell's call inventory as complete.
pub fn mark_tool_calls_complete(&mut self) {
if let Some(metadata) = self.ensure_tool_call_metadata() {
metadata.tool_calls_complete = Some(true);