diff --git a/codex-rs/codex-mcp/src/binding.rs b/codex-rs/codex-mcp/src/binding.rs index 8bf47bea87..9ab5486095 100644 --- a/codex-rs/codex-mcp/src/binding.rs +++ b/codex-rs/codex-mcp/src/binding.rs @@ -15,7 +15,9 @@ use std::time::Duration; use anyhow::Context; use anyhow::Result; use codex_config::AppToolApproval; +use codex_config::McpServerAuth; use codex_exec_server::FileSystemSandboxContext; +use codex_protocol::auth::AuthMode; use codex_protocol::mcp::CallToolResult; use codex_protocol::models::PermissionProfile; use codex_utils_absolute_path::AbsolutePathBuf; @@ -355,6 +357,39 @@ impl PreparedMcpCall { }) } + /// Whether this completed Apps call can supply its result body to the session. + pub fn permits_result_body(&self, session_auth: AuthMode) -> bool { + let Some(server) = self.config.mcp_server_catalog.server(self.server_key()) else { + return false; + }; + let config = server.config(); + let codex_config::McpServerTransportConfig::StreamableHttp { + url, + http_headers, + env_http_headers, + bearer_token_env_var: None, + http_headers_helper: None, + } = &config.transport + else { + return false; + }; + matches!( + session_auth, + AuthMode::Chatgpt | AuthMode::ChatgptAuthTokens + ) && config.auth == McpServerAuth::ChatGpt + && http_headers + .iter() + .flat_map(HashMap::keys) + .chain(env_http_headers.iter().flat_map(HashMap::keys)) + .all(|name| is_apps_attribution_header(name)) + && self.client.client.matches_result_body_source( + /*require_runtime_auth*/ true, + url, + http_headers.as_ref(), + env_http_headers.as_ref(), + ) + } + pub fn server_origin(&self) -> Option<&str> { self.server_metadata .origin @@ -514,6 +549,10 @@ impl PreparedMcpCall { } } +fn is_apps_attribution_header(name: &str) -> bool { + name.eq_ignore_ascii_case("x-openai-product-sku") || name.eq_ignore_ascii_case("originator") +} + pub(crate) fn call_tool_result_from_rmcp(result: rmcp::model::CallToolResult) -> CallToolResult { let content = result .content diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index a706695448..83704a7df6 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -976,6 +976,9 @@ "concurrent_reasoning_summaries": { "type": "boolean" }, + "connector_tool_result_passthrough": { + "type": "boolean" + }, "connectors": { "type": "boolean" }, @@ -8341,6 +8344,9 @@ "concurrent_reasoning_summaries": { "type": "boolean" }, + "connector_tool_result_passthrough": { + "type": "boolean" + }, "connectors": { "type": "boolean" }, diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index 4e20215925..80e31f978d 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -92,6 +92,7 @@ use codex_protocol::ThreadId; use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig; use codex_protocol::config_types::Verbosity as VerbosityConfig; use codex_protocol::models::ResponseItem; +use codex_protocol::models::ToolResultBody; use codex_protocol::openai_models::ModelInfo; use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig; use codex_protocol::protocol::AuthRecoveryEvent; @@ -136,6 +137,7 @@ use crate::context::ContextualUserFragment; use crate::cyber_access_program; use crate::feedback_tags; use crate::responses_metadata::CodexResponsesMetadata; +use crate::responses_metadata::CodexResponsesRequestKind; use crate::responses_metadata::subagent_header_value; use crate::session::turn_context::TurnContext; use crate::util::emit_feedback_auth_recovery_tags; @@ -280,6 +282,43 @@ enum ClientRouting { ConfiguredProvider, } +pub(crate) fn is_local_connector_result_gateway(base_url: &str) -> bool { + let url = base_url.strip_suffix('/').unwrap_or(base_url); + matches!( + url, + codex_model_provider_info::CHATGPT_CODEX_BASE_URL + | "https://chatgpt-staging.com/backend-api/codex" + ) +} + +fn sampling_result_owner( + setup: &CurrentClientSetup, + include_internal: bool, + responses_headers: &ApiHeaderMap, +) -> Option { + setup + .auth_owner + .as_ref() + .filter(|owner| { + owner.is_current() + && include_internal + && responses_headers.is_empty() + && matches!( + setup.auth.as_ref().map(CodexAuth::auth_mode), + Some(AuthMode::Chatgpt | AuthMode::ChatgptAuthTokens) + ) + && is_local_connector_result_gateway(&setup.api_provider.base_url) + && setup.api_provider.headers.keys().all(|name| { + matches!( + name.as_str(), + codex_model_provider::ACCOUNT_ROUTING_HEADER + | codex_model_provider_info::RESIDENCY_HEADER_NAME + ) || ExecutedToolCalls::is_result_body_provider_header(name.as_str()) + }) + }) + .cloned() +} + #[derive(Clone, Copy)] struct RequestRouteTelemetry { endpoint: &'static str, @@ -1314,8 +1353,12 @@ impl ModelClient { .any(|supported| supported.id == *tier) }); if !include_internal { + let captures_result_bodies = self.captures_result_bodies(); for item in &mut input { item.clear_tool_result_metadata(); + if captures_result_bodies { + item.clear_tool_result_ids(); + } } } let client_metadata = responses_metadata.client_metadata(include_internal); @@ -1410,6 +1453,46 @@ impl ModelClient { .await } + fn prepared_prompt_for_trace( + &self, + attempt: &InferenceTraceAttempt, + prompt: &Arc, + ) -> Arc { + let mut prepared = Arc::clone(prompt); + if attempt.is_enabled() + && let Some(recorder) = &self.executed_tool_calls + { + recorder.scope_request_metadata_with(|| &mut Arc::make_mut(&mut prepared).input); + } + prepared + } + + fn captures_result_bodies(&self) -> bool { + self.executed_tool_calls + .as_ref() + .is_some_and(ExecutedToolCalls::captures_result_bodies) + } + + /// Collect bodies only after selecting the inference credentials and the physical input. + fn sampling_result_bodies( + &self, + metadata: &CodexResponsesMetadata, + owner: Option, + input: &[ResponseItem], + ) -> Vec<(usize, usize, Arc)> { + if let Some(owner) = owner + && matches!(metadata.request_kind, Some(CodexResponsesRequestKind::Turn)) + && let Some(turn_id) = metadata.turn_id.as_deref() + && let Some(turn) = self + .executed_tool_calls + .as_ref() + .and_then(|calls| calls.result_body_turn(turn_id)) + { + return turn.for_input(input, &owner); + } + Vec::new() + } + fn responses_headers(&self, auth: Option<&CodexAuth>, model: &str) -> ApiHeaderMap { self.codex_responses_headers .as_ref() @@ -2040,6 +2123,11 @@ impl ResponsesHttpExecutor<'_> { let responses_headers = self .client .responses_headers(client_setup.auth.as_ref(), &model_info.slug); + let result_body_owner = sampling_result_owner( + &client_setup, + include_internal && self.client.captures_result_bodies(), + &responses_headers, + ); tracing::Span::current().record("api.path", "/responses"); let transport = client_setup.http_transport("/responses")?; let request_auth_context = AuthRequestTelemetryContext::new( @@ -2106,6 +2194,9 @@ impl ResponsesHttpExecutor<'_> { let history_ids = inference_trace.stripped_output_ids(&request.input); self.client .prepare_response_items_for_request(&mut request.input); + if let Some(recorder) = &self.client.executed_tool_calls { + let _ = recorder.scope_request_metadata(&mut request.input); + } let request_session_telemetry = session_telemetry_for_request(session_telemetry, &request); options.extra_headers.extend(responses_headers); @@ -2143,11 +2234,17 @@ impl ResponsesHttpExecutor<'_> { client_setup.api_auth, ) .with_telemetry(Some(request_telemetry), Some(sse_telemetry)); + options.tool_results = self.client.sampling_result_bodies( + responses_metadata, + result_body_owner, + &request.input, + ); let stream_result = client .stream_request_with_observer(request, options, |wire| { inference_trace_attempt.record_started( wire.clone(), - Arc::clone(prompt), + self.client + .prepared_prompt_for_trace(&inference_trace_attempt, prompt), history_ids, || Ok(None), ); @@ -2442,6 +2539,16 @@ impl ModelClientSession { .prepare_response_items_for_request(&mut request.input); Some(original_item_ids) }; + let mut original_metadata = Vec::new(); + if let Some(recorder) = &self.client.executed_tool_calls { + if let Some(items) = &mut incremental_items { + let _ = recorder.scope_request_metadata(items); + } + // A continuation from a warmup also records the full context for rollout replay. + if incremental_items.is_none() || previous_response_id_from_untraced_warmup { + original_metadata = recorder.scope_request_metadata(&mut request.input); + } + } let mut request = Arc::new(request); let mut ws_payload = ResponseCreateWsRequest { previous_response_id, @@ -2516,7 +2623,8 @@ impl ModelClientSession { |wire| { inference_trace_attempt.record_started( wire.clone(), - Arc::clone(prompt), + self.client + .prepared_prompt_for_trace(&inference_trace_attempt, prompt), history_ids, move || { #[derive(serde::Serialize)] @@ -2540,6 +2648,12 @@ impl ModelClientSession { item.set_id(original_item_id); } } + if !original_metadata.is_empty() { + ExecutedToolCalls::restore_request_metadata( + &mut Arc::make_mut(&mut request).input, + original_metadata, + ); + } self.websocket_session.last_request = Some(request); self.websocket_session.last_response_from_untraced_warmup = warmup; let stream_result = stream_result.map_err(|err| { diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rs index 36416ad3ad..db58251c44 100644 --- a/codex-rs/core/src/client_tests.rs +++ b/codex-rs/core/src/client_tests.rs @@ -12,6 +12,7 @@ use super::X_CODEX_PARENT_THREAD_ID_HEADER; use super::X_CODEX_TURN_METADATA_HEADER; use super::X_CODEX_WINDOW_ID_HEADER; use super::X_OPENAI_SUBAGENT_HEADER; +use super::sampling_result_owner; use crate::AttestationContext; use crate::AttestationProvider; use crate::GenerateAttestationFuture; @@ -430,6 +431,7 @@ async fn client_setup_rebuilds_chatgpt_refresh_but_rejects_account_switches() { AuthManager::from_auth_for_testing_with_home(initial, home.path().to_path_buf()); let refreshed_token = token(user, "refreshed"); let mut info = test_model_provider().info().clone(); + info.base_url = Some(CHATGPT_CODEX_BASE_URL.to_string()); info.requires_openai_auth = true; let provider = Arc::new(SetupRefreshProvider { inner: create_model_provider(info, Some(manager.clone())), @@ -446,13 +448,32 @@ async fn client_setup_rebuilds_chatgpt_refresh_but_rejects_account_switches() { .current_client_setup(super::ClientRouting::ConfiguredProvider) .await; if expected_calls == 2 { - let setup = result.unwrap(); + let mut setup = result.unwrap(); let mut headers = http::HeaderMap::new(); setup.api_auth.add_auth_headers(&mut headers).unwrap(); assert_eq!( headers.get(http::header::AUTHORIZATION).unwrap(), &format!("Bearer {refreshed_token}") ); + let empty = http::HeaderMap::new(); + for (internal, response_headers, owner) in [ + (true, &empty, setup.auth_owner.clone()), + (false, &empty, None), + (true, &headers, None), + ] { + assert_eq!( + sampling_result_owner(&setup, internal, response_headers), + owner + ); + } + setup.api_provider.headers.insert( + "openai-organization", + http::HeaderValue::from_static("another-organization"), + ); + assert_eq!( + sampling_result_owner(&setup, /*include_internal*/ true, &empty), + None, + ); assert_eq!(setup.auth.unwrap().get_token().unwrap(), refreshed_token); assert_eq!( (setup.auth_revision, setup.auth_owner), @@ -1445,7 +1466,9 @@ where } } -fn started_inference_attempt(temp: &TempDir) -> anyhow::Result { +fn inference_trace_fixture( + temp: &TempDir, +) -> anyhow::Result<(Arc, InferenceTraceAttempt)> { let writer = Arc::new(TraceWriter::create( temp.path(), "trace-1".to_string(), @@ -1469,7 +1492,11 @@ fn started_inference_attempt(temp: &TempDir) -> anyhow::Result anyhow::Result { + let (writer, attempt) = inference_trace_fixture(temp)?; let request = json!({ "model": "gpt-test", "input": [{ @@ -1489,6 +1516,66 @@ fn started_inference_attempt(temp: &TempDir) -> anyhow::Result anyhow::Result<()> { + let mut bound = + ExecutedToolCall::new("mcp__codex_apps__search".into(), json!({"query": "docs"})); + bound.set_tool_result_metadata( + ToolResultMetadata::default().with_result_id(Some(uuid::Uuid::new_v4())), + ); + let unbound = ExecutedToolCall::new( + "exec_command".into(), + json!({"cmd": "unbound-shell-argument"}), + ); + let mut item = ResponseItem::from(ResponseInputItem::CustomToolCallOutput { + call_id: "exec".into(), + name: None, + output: FunctionCallOutputPayload::from_text("done".into()), + }); + item.append_executed_tool_calls(vec![unbound.clone(), bound.clone()]); + let prompt = Arc::new(Prompt { + input: vec![item], + ..Default::default() + }); + + for general in [false, true] { + let mut features = codex_features::Features::default(); + features.enable(codex_features::Feature::ConnectorToolResultPassthrough); + if general { + features.enable(codex_features::Feature::ExecutedToolCallMetadata); + } + let mut client = test_model_client(SessionSource::Cli); + client.executed_tool_calls = Some(crate::tools::ExecutedToolCalls::new( + &features, + &codex_history::InitialHistory::New, + )); + let temp = TempDir::new()?; + let (writer, attempt) = inference_trace_fixture(&temp)?; + let prepared = client.prepared_prompt_for_trace(&attempt, &prompt); + attempt.record_started(br#"{"input":[]}"#, prepared, Vec::new(), || Ok(None)); + writer.flush()?; + let rollout = replay_bundle(temp.path())?; + let payload = rollout + .raw_payloads + .values() + .find(|p| p.kind == RawPayloadKind::PreparedPrompt) + .expect("prepared prompt payload"); + let recorded: serde_json::Value = serde_json::from_slice( + codex_rollout_trace::PayloadReader::new(temp.path()).read(payload)?, + )?; + let expected = if general { + json!([unbound, bound]) + } else { + json!([bound]) + }; + assert_eq!( + recorded["input"][0]["internal_chat_message_metadata_passthrough"]["executed_tool_calls"], + expected + ); + } + Ok(()) +} + fn output_message(id: &str, text: &str) -> ResponseItem { ResponseItem::Message { status: None, diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs index 66722ccc18..2d931d342a 100644 --- a/codex-rs/core/src/mcp_tool_call.rs +++ b/codex-rs/core/src/mcp_tool_call.rs @@ -169,6 +169,7 @@ pub(crate) async fn handle_mcp_tool_call( invocation_tool_name: ToolName, source: &crate::tools::context::ToolCallSource, arguments: String, + observe_server_result: impl FnOnce(&PreparedMcpCall, &CallToolResult), ) -> Result { let turn_context = &step_context.turn; let server = advertised_tool.server_name().to_owned(); @@ -325,6 +326,7 @@ pub(crate) async fn handle_mcp_tool_call( metadata, item_metadata, source, + observe_server_result, McpToolApprovalApplication::Apply { decision, policy: approval_policy, @@ -417,6 +419,7 @@ pub(crate) async fn handle_mcp_tool_call( metadata, item_metadata, source, + observe_server_result, McpToolApprovalApplication::NotRequired, ) .await @@ -488,6 +491,7 @@ async fn handle_approved_mcp_tool_call( metadata: &McpToolApprovalMetadata, item_metadata: McpToolCallItemMetadata, source: &crate::tools::context::ToolCallSource, + observe_server_result: impl FnOnce(&PreparedMcpCall, &CallToolResult), approval_application: McpToolApprovalApplication, ) -> Result { let turn_context = step_context.turn.as_ref(); @@ -719,6 +723,7 @@ async fn handle_approved_mcp_tool_call( &result, ); let mut result = result?; + observe_server_result(&prepared_call, &result); crate::tools::record_confirmed_code_mode_send( sess, &turn_context.sub_id, diff --git a/codex-rs/core/src/mcp_tool_call/conversation_history.rs b/codex-rs/core/src/mcp_tool_call/conversation_history.rs index 0ed58aa266..68f183c18b 100644 --- a/codex-rs/core/src/mcp_tool_call/conversation_history.rs +++ b/codex-rs/core/src/mcp_tool_call/conversation_history.rs @@ -175,6 +175,7 @@ impl<'call> ToolExecutor> for HistoryTool { result, tool_input: arguments, result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: started.elapsed(), original_image_detail_supported: false, truncation_policy, diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index 5bd06d2756..f12a03dc97 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -456,6 +456,7 @@ impl Session { let storage_originator = AuthStorageOriginator::from_client_name(&turn_context.originator); let task_future = async move { let ctx_for_finish = Arc::clone(&ctx); + let mut _tool_result_capture = None; let mut task_result = async { let input = match host_admission { Some(provider) => admission::admit( @@ -467,6 +468,9 @@ impl Session { ).await?, None => task_input, }; + if task_kind == TaskKind::Regular { + _tool_result_capture = session.services.executed_tool_calls.begin_turn(&ctx); + } task_for_run .run( Arc::clone(&session), diff --git a/codex-rs/core/src/tools/context.rs b/codex-rs/core/src/tools/context.rs index d70e2998c5..2d06815ef6 100644 --- a/codex-rs/core/src/tools/context.rs +++ b/codex-rs/core/src/tools/context.rs @@ -3,6 +3,7 @@ use crate::session::session::Session; use crate::session::step_context::StepContext; use crate::session::turn_context::TurnContext; use crate::session::turn_context::TurnEnvironment; +use crate::tools::executed_tool_calls::PendingResultBody; use crate::turn_diff_tracker::TurnDiffTracker; use crate::unified_exec::output::CapturedStream; use crate::unified_exec::resolve_max_tokens; @@ -14,6 +15,7 @@ use codex_protocol::models::FunctionCallOutputContentItem; use codex_protocol::models::FunctionCallOutputPayload; use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; +use codex_protocol::models::ToolResultMetadata; use codex_protocol::models::function_call_output_content_items_to_text; use codex_tools::LoadableToolSpec; use codex_tools::ToolName; @@ -174,6 +176,7 @@ pub struct McpToolOutput { pub tool_input: JsonValue, // Keep the original metadata for hooks; this flag only controls analytics capture. pub(crate) result_metadata_capture_allowed: bool, + pub(crate) result_capture: Option>, pub wall_time: Duration, pub original_image_detail_supported: bool, pub truncation_policy: TruncationPolicy, @@ -215,11 +218,21 @@ impl ToolOutput for McpToolOutput { self.result.code_mode_result(payload) } - fn tool_result_metadata(&self) -> Option<&JsonValue> { + fn tool_result_metadata(&self) -> ToolResultMetadata { if !self.result_metadata_capture_allowed { - return None; + return ToolResultMetadata::default(); } - self.result.meta.as_ref() + let result_id = self + .result_capture + .as_ref() + .filter(|_| self.result.success()) + .and_then(|capture| capture.accept()); + self.result + .meta + .as_ref() + .map(ToolResultMetadata::new) + .unwrap_or_default() + .with_result_id(result_id) } fn post_tool_use_input(&self, _payload: &ToolPayload) -> Option { diff --git a/codex-rs/core/src/tools/context_tests.rs b/codex-rs/core/src/tools/context_tests.rs index aa9a5f37e5..bde6cbc328 100644 --- a/codex-rs/core/src/tools/context_tests.rs +++ b/codex-rs/core/src/tools/context_tests.rs @@ -100,6 +100,7 @@ fn mcp_tool_output_response_item_includes_wall_time() { }, tool_input: json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: std::time::Duration::from_millis(1250), original_image_detail_supported: false, truncation_policy: TruncationPolicy::Bytes(1024), @@ -147,6 +148,7 @@ fn mcp_tool_output_response_item_truncates_large_structured_content() { }, tool_input: json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: std::time::Duration::from_millis(1250), original_image_detail_supported: false, truncation_policy: TruncationPolicy::Bytes(128), @@ -198,6 +200,7 @@ fn mcp_tool_output_response_item_preserves_content_items() { }, tool_input: json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: std::time::Duration::from_millis(500), original_image_detail_supported: false, truncation_policy: TruncationPolicy::Bytes(1024), @@ -260,6 +263,7 @@ fn mcp_tool_output_code_mode_result_preserves_content_without_private_metadata( }, tool_input: json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: std::time::Duration::from_millis(1250), original_image_detail_supported: false, truncation_policy, diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rs index 563acf59d8..99482a1665 100644 --- a/codex-rs/core/src/tools/executed_tool_calls.rs +++ b/codex-rs/core/src/tools/executed_tool_calls.rs @@ -13,6 +13,7 @@ use std::sync::Arc; use std::sync::Mutex; use std::sync::MutexGuard; use std::sync::Weak; +use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -20,25 +21,33 @@ use codex_code_mode::CellId; use codex_features::Feature; use codex_features::Features; use codex_history::InitialHistory; +use codex_login::AuthOwner; +use codex_model_provider::provider_uses_first_party_auth_path; use codex_protocol::ResponseItemId; +use codex_protocol::auth::AuthMode; +use codex_protocol::mcp::CallToolResult; use codex_protocol::mcp::McpAttribution; use codex_protocol::mcp::McpAttributionSource; use codex_protocol::models::ExecutedToolCall; use codex_protocol::models::ExecutedToolCallArguments; use codex_protocol::models::ResponseItem; +use codex_protocol::models::ToolResultBody; use codex_protocol::models::ToolResultMetadata; use codex_protocol::models::executed_tool_call_metadata_bytes; use codex_protocol::models::normalize_executed_tool_call_completeness; use codex_protocol::openai_models::ToolMode; use indexmap::IndexMap; use serde_json::Value as JsonValue; +use uuid::Uuid; use crate::session::step_context::StepContext; +use crate::session::turn_context::TurnContext; use crate::tools::context::ToolCallSource; use crate::tools::context::ToolOutput; use crate::tools::context::ToolPayload; use crate::tools::metadata_metrics; use crate::tools::router::ToolCall; +use crate::turn_metadata::TurnMetadataState; use codex_utils_string::serialized_json_bytes; mod seen_ids; @@ -50,6 +59,7 @@ const MAX_PENDING_EXECUTED_TOOL_CALLS: usize = 256; // 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; +const MAX_TURN_RESULT_BODY_BYTES: usize = 1024 * 1024; type ExecutedToolCallCache = HashMap<(std::mem::Discriminant, String), Vec>; @@ -59,11 +69,134 @@ type ExecutedToolCallCache = #[derive(Clone, Default)] pub(crate) struct ExecutedToolCalls { state: Arc>>, + captures_result_bodies: bool, retained_direct_metadata_bytes: Arc, pending_direct_calls: Arc, mcp_attribution: mcp_attribution::McpAttributionRecorder, } +/// Private bytes belong to one regular task. History keeps only the host-issued IDs. +pub(crate) struct ResultBodyTurn { + turn_id: String, + origin: Weak, + owner: AuthOwner, + auth_mode: AuthMode, + retained: Mutex, +} + +#[derive(Default)] +struct RetainedResultBodies { + by_id: HashMap>, + bytes: usize, +} + +/// Refund the provisional slot when a callback blocks or the call is cancelled. +#[derive(Debug)] +pub(crate) struct PendingResultBody { + turn: Weak, + id: Uuid, + accepted: AtomicBool, +} + +impl PendingResultBody { + fn record(turn: &Arc, result: &CallToolResult) -> Option> { + Some(Arc::new(Self { + id: turn.record(result)?, + turn: Arc::downgrade(turn), + accepted: AtomicBool::new(false), + })) + } + + pub(super) fn accept(&self) -> Option { + self.turn.upgrade().filter(|turn| turn.is_current())?; + self.accepted.store(true, Ordering::Relaxed); + Some(self.id) + } +} + +impl Drop for PendingResultBody { + fn drop(&mut self) { + if !*self.accepted.get_mut() { + ResultBodyTurn::discard(&self.turn, Some(self.id)); + } + } +} + +impl ResultBodyTurn { + fn discard_call(turn: &Weak, call: &mut ExecutedToolCall) { + Self::discard(turn, call.tool_result_id()); + call.clear_tool_result_id(); + } + + fn discard(turn: &Weak, id: Option) { + if let Some(id) = id + && let Some(turn) = turn.upgrade() + { + let mut retained = turn.lock_bodies(); + if let Some(body) = retained.by_id.remove(&id) { + retained.bytes -= body.compact_bytes(); + } + } + } + + fn is_current(&self) -> bool { + self.owner.is_current() + } + + fn lock_bodies(&self) -> MutexGuard<'_, RetainedResultBodies> { + self.retained + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + } + + pub(super) fn record(&self, result: &CallToolResult) -> Option { + if !self.is_current() { + return None; + } + let body = ToolResultBody::from_mcp_result(result)?; + let mut retained = self.lock_bodies(); + if retained.by_id.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS + || body.compact_bytes() > MAX_TURN_RESULT_BODY_BYTES - retained.bytes + { + return None; + } + let id = Uuid::new_v4(); + retained.bytes += body.compact_bytes(); + retained.by_id.insert(id, Arc::new(body)); + Some(id) + } + + /// Select the existing call records on this authorized sampling request. + pub(crate) fn for_input( + &self, + input: &[ResponseItem], + selected_owner: &AuthOwner, + ) -> Vec<(usize, usize, Arc)> { + let mut results = Vec::new(); + if self.owner != *selected_owner || !self.is_current() { + return results; + } + let retained = self.lock_bodies(); + if retained.by_id.is_empty() { + return results; + } + for (index, item) in input.iter().enumerate() { + let Some(calls) = item + .executed_tool_call_metadata() + .and_then(|metadata| metadata.executed_tool_calls.as_deref()) + else { + continue; + }; + for (row, call) in calls.iter().enumerate() { + if let Some(body) = call.tool_result_id().and_then(|id| retained.by_id.get(&id)) { + results.push((index, row, Arc::clone(body))); + } + } + } + results + } +} + // Avoid exposing recorded call arguments or result metadata through client Debug output. impl std::fmt::Debug for ExecutedToolCalls { fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -93,10 +226,12 @@ impl Drop for DirectCallPermit { #[derive(Default)] struct ExecutedToolCallRecorderState { + include_general_metadata: bool, // Disabling drops this lifetime, permanently invalidating prepared Direct records. recording: Arc<()>, // Full live Direct observations; persisted outputs keep their bounded projection. direct_calls: HashMap, + body_turn: Weak, cells: HashMap, output_cells: HashMap, retained_calls: HashMap<(std::mem::Discriminant, String), RetainedToolCalls>, @@ -249,8 +384,10 @@ impl ExecutedToolCallRecorderState { impl ExecutedToolCalls { pub(crate) fn new(features: &Features, history: &InitialHistory) -> Self { Self { + captures_result_bodies: features.enabled(Feature::ConnectorToolResultPassthrough), state: Arc::new(Mutex::new(Self::is_enabled(features).then(|| { ExecutedToolCallRecorderState { + include_general_metadata: features.enabled(Feature::ExecutedToolCallMetadata), seen_ids: SeenIds::from_history(history), // Runtime cell IDs can restart after resume/fork; inherited wait // handles cannot be distinguished from newly allocated handles. @@ -267,6 +404,99 @@ impl ExecutedToolCalls { } } + pub(crate) fn is_result_body_provider_header(name: &str) -> bool { + name.eq_ignore_ascii_case("version") || name.eq_ignore_ascii_case("x-openai-originator") + } + + pub(crate) fn captures_result_bodies(&self) -> bool { + self.captures_result_bodies + } + + pub(crate) fn begin_turn(&self, turn: &TurnContext) -> Option> { + if !self.captures_result_bodies + || !turn + .config + .features + .enabled(Feature::ConnectorToolResultPassthrough) + { + return None; + } + let manager = turn.auth_manager.as_ref()?; + let info = turn.provider.info(); + // The built-in provider declares optional organization/project selectors. The + // transport checks the resolved headers again and declines either active selector. + if info.is_amazon_bedrock() + || info.is_gcp() + || !provider_uses_first_party_auth_path(info) + || info.gateway_oauth.is_some() + || !turn + .provider + .auth_manager() + .is_some_and(|provider| Arc::ptr_eq(manager, &provider)) + || info + .query_params + .as_ref() + .is_some_and(|params| !params.is_empty()) + || info + .http_headers + .iter() + .flat_map(HashMap::keys) + .chain(info.env_http_headers.iter().flat_map(HashMap::keys)) + .any(|name| { + !Self::is_result_body_provider_header(name) + && !name.eq_ignore_ascii_case(codex_client::OPENAI_ORGANIZATION_HEADER) + && !name.eq_ignore_ascii_case(codex_client::OPENAI_PROJECT_HEADER) + }) + { + return None; + } + let owner = manager.auth_owner(); + let auth_mode = manager.auth_mode().filter(|_| owner.is_current())?; + if !matches!(auth_mode, AuthMode::Chatgpt | AuthMode::ChatgptAuthTokens) + || !info + .base_url + .as_deref() + .is_none_or(crate::client::is_local_connector_result_gateway) + { + return None; + } + let capture = Arc::new(ResultBodyTurn { + owner, + auth_mode, + turn_id: turn.sub_id.clone(), + origin: Arc::downgrade(&turn.turn_metadata_state), + retained: Mutex::default(), + }); + self.lock_state().as_mut()?.body_turn = Arc::downgrade(&capture); + Some(capture) + } + + pub(crate) fn result_body_turn(&self, turn_id: &str) -> Option> { + if !self.captures_result_bodies { + return None; + } + self.lock_state() + .as_ref()? + .body_turn + .upgrade() + .filter(|capture| capture.turn_id == turn_id) + } + + pub(super) fn capture_mcp_result( + &self, + turn: &TurnContext, + call: &codex_mcp::PreparedMcpCall, + result: &CallToolResult, + ) -> Option> { + let capture = self.result_body_turn(&turn.sub_id).filter(|capture| { + capture + .origin + .ptr_eq(&Arc::downgrade(&turn.turn_metadata_state)) + && call.permits_result_body(capture.auth_mode) + })?; + PendingResultBody::record(&capture, result) + } + pub(crate) fn record_mcp_source(&self, source: McpAttributionSource) { self.mcp_attribution.record(source); } @@ -356,7 +586,8 @@ impl ExecutedToolCalls { /// Called under the session config lock; this never changes execution features. pub(crate) fn refresh(&self, features: &Features) { - let enabled = Self::is_enabled(features); + let include_general_metadata = features.enabled(Feature::ExecutedToolCallMetadata); + let enabled = self.captures_result_bodies || include_general_metadata; let mut state = self.lock_state(); if enabled != state.is_some() { *state = enabled.then(|| ExecutedToolCallRecorderState { @@ -364,11 +595,15 @@ impl ExecutedToolCalls { ..Default::default() }); } + if let Some(state) = state.as_mut() { + state.include_general_metadata = include_general_metadata; + } } /// The turn's feature policy is independent of whether this session has a recorder. pub(crate) fn is_enabled(features: &Features) -> bool { features.enabled(Feature::ExecutedToolCallMetadata) + || features.enabled(Feature::ConnectorToolResultPassthrough) } pub(crate) fn record_tool_call( @@ -416,22 +651,30 @@ impl ExecutedToolCalls { prepared: Option<(ExecutedToolCall, DirectCallPermit)>, item_id_generator: &codex_protocol::ItemIdGenerator, ) { - let Some((call, permit)) = prepared else { + let Some((mut call, permit)) = prepared else { return; }; let mut state = self.lock_state(); let Some(state) = state.as_mut() else { return; }; - if !permit.recording.ptr_eq(&Arc::downgrade(&state.recording)) { + if !permit.recording.ptr_eq(&Arc::downgrade(&state.recording)) + || (!state.include_general_metadata && call.tool_result_id().is_none()) + { return; } crate::session::assign_missing_item_id(item, item_id_generator); - if let Some(id) = item.id() { - state.direct_calls.insert(id.clone(), call.clone()); + let keep_live_call = !self.captures_result_bodies + || state.direct_calls.len() < MAX_PENDING_EXECUTED_TOOL_CALLS + || item + .id() + .is_some_and(|id| state.direct_calls.contains_key(id)); + if !keep_live_call { + // The ordinary bounded observation can still travel on the output itself. + ResultBodyTurn::discard_call(&state.body_turn, &mut call); } let complete = call.has_complete_inventory(); - item.append_executed_tool_calls(vec![call]); + item.append_executed_tool_calls(vec![call.clone()]); if complete { item.mark_tool_calls_complete(); } @@ -453,13 +696,11 @@ impl ExecutedToolCalls { } if bytes > available { item.clear_executed_tool_calls(); - metadata_metrics::record_shedding( - "direct_retained", - original_bytes, - executed_tool_call_metadata_bytes(item), - codex_otel::global().as_ref(), - ); - return; + ResultBodyTurn::discard_call(&state.body_turn, &mut call); + bytes = executed_tool_call_metadata_bytes(item); + } + if keep_live_call && let Some(id) = item.id() { + state.direct_calls.insert(id.clone(), call); } // All Direct attachments share the recorder lock, including cloned handles. self.retained_direct_metadata_bytes @@ -497,8 +738,8 @@ impl ExecutedToolCalls { } // 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() { - self.record_tool_result_metadata(source, call_id, metadata); + if recording { + self.record_result_metadata(source, call_id, result.tool_result_metadata()); } } @@ -600,17 +841,18 @@ impl ExecutedToolCalls { } } - fn record_tool_result_metadata( + fn record_result_metadata( &self, source: &ToolCallSource, call_id: &str, - metadata: &JsonValue, + metadata: ToolResultMetadata, ) -> bool { let ToolCallSource::CodeMode { cell_id, .. } = source else { return false; }; - let metadata = ToolResultMetadata::new(metadata); - let has_metadata = metadata.is_some(); + if !metadata.has_observation() { + return false; + } let mut state = self.lock_state(); let Some(state) = state.as_mut() else { return false; @@ -621,7 +863,7 @@ impl ExecutedToolCalls { .and_then(|cell| cell.pending_calls.get_mut(call_id)); if let Some(call) = call { call.set_tool_result_metadata(metadata); - return has_metadata; + return true; } let retained_call = state.retained_calls.values_mut().find_map(|retained| { if retained.runtime_cell_id.as_ref()?.as_str() != cell_id.as_str() { @@ -634,7 +876,7 @@ impl ExecutedToolCalls { // Older retry copies must not overwrite this output's accepted result metadata. retained.result_metadata_updated = true; retained.calls[index].set_tool_result_metadata(metadata); - return has_metadata; + return true; } let mut candidates = state.retained_calls.values_mut().filter_map(|retained| { if retained.runtime_cell_id.as_ref()?.as_str() != cell_id.as_str() { @@ -652,7 +894,7 @@ impl ExecutedToolCalls { retained.late_truncated_indices.insert(index); retained.result_metadata_updated = true; retained.calls[index].set_tool_result_metadata(metadata); - has_metadata + true } pub(crate) fn register_cell(&self, cell_id: &CellId, output_call_id: &str) { diff --git a/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs b/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs index 01d0056b59..cff6b601f8 100644 --- a/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs +++ b/codex-rs/core/src/tools/executed_tool_calls/request_metadata.rs @@ -1,6 +1,7 @@ //! Attaches host observations to request metadata without changing tool execution. use super::*; +use codex_protocol::models::InternalChatMessageMetadataPassthrough; #[derive(Clone, Copy, PartialEq, Eq)] enum RequestKind { @@ -9,6 +10,100 @@ enum RequestKind { } impl ExecutedToolCalls { + /// Projects only the wire metadata; retained calls keep their original indexes for late results. + /// Restore full WebSocket inputs before saving them as the continuation baseline. + pub(crate) fn scope_request_metadata( + &self, + items: &mut [ResponseItem], + ) -> Vec<(usize, InternalChatMessageMetadataPassthrough)> { + self.scope_request_metadata_with(|| items) + } + + /// Only request mutable input when a connector-only projection is needed. + pub(crate) fn scope_request_metadata_with<'a>( + &self, + items: impl FnOnce() -> &'a mut [ResponseItem], + ) -> Vec<(usize, InternalChatMessageMetadataPassthrough)> { + if !self.captures_result_bodies + || self + .lock_state() + .as_ref() + .is_some_and(|state| state.include_general_metadata) + { + return Vec::new(); + } + let mut originals = Vec::new(); + for (index, item) in items().iter_mut().enumerate() { + let (ResponseItem::FunctionCallOutput { + internal_chat_message_metadata_passthrough: Some(metadata), + .. + } + | ResponseItem::CustomToolCallOutput { + internal_chat_message_metadata_passthrough: Some(metadata), + .. + } + | ResponseItem::ToolSearchOutput { + internal_chat_message_metadata_passthrough: Some(metadata), + .. + }) = item + else { + continue; + }; + if metadata.executed_tool_calls.is_none() + && metadata.cell_id.is_none() + && metadata.tool_calls_complete.is_none() + { + continue; + } + if metadata.tool_calls_complete.is_none() + && metadata.executed_tool_calls.as_ref().is_some_and(|calls| { + !calls.is_empty() && calls.iter().all(|call| call.tool_result_id().is_some()) + }) + { + continue; + } + originals.push((index, metadata.clone())); + if let Some(calls) = metadata.executed_tool_calls.as_mut() { + calls.retain(|call| call.tool_result_id().is_some()); + } + // Earlier outputs from this cell can have omitted unrelated calls, including on a + // previous frame. A connector-only subset cannot claim a complete cell inventory. + metadata.tool_calls_complete = None; + if metadata + .executed_tool_calls + .as_ref() + .is_none_or(Vec::is_empty) + { + metadata.executed_tool_calls = None; + metadata.cell_id = None; + } + } + originals + } + + pub(crate) fn restore_request_metadata( + items: &mut [ResponseItem], + originals: Vec<(usize, InternalChatMessageMetadataPassthrough)>, + ) { + for (index, original) in originals { + if let ResponseItem::FunctionCallOutput { + internal_chat_message_metadata_passthrough: metadata, + .. + } + | ResponseItem::CustomToolCallOutput { + internal_chat_message_metadata_passthrough: metadata, + .. + } + | ResponseItem::ToolSearchOutput { + internal_chat_message_metadata_passthrough: metadata, + .. + } = &mut items[index] + { + *metadata = Some(original); + } + } + } + pub(crate) fn attach_to_compaction_prompt(&self, items: &mut [ResponseItem]) { self.attach_to_request(items, &mut HashMap::new(), RequestKind::Compaction); } @@ -36,8 +131,22 @@ impl ExecutedToolCalls { }; for item in items.iter_mut() { if let Some(call) = item.id().and_then(|id| state.direct_calls.get(id)) { + let keep_result_id = call.tool_result_id().is_none_or(|id| { + item.executed_tool_call_metadata().is_some_and(|metadata| { + metadata.cell_id.is_none() + && matches!( + metadata.executed_tool_calls.as_deref(), + Some([original]) if original.tool_result_id() == Some(id) + ) + }) + }); + // Release the old arguments and metadata before cloning the cached row. item.clear_executed_tool_calls(); - item.append_executed_tool_calls(vec![call.clone()]); + let mut observation = call.clone(); + if !keep_result_id { + observation.clear_tool_result_id(); + } + item.append_executed_tool_calls(vec![observation]); if call.has_complete_inventory() { item.mark_tool_calls_complete(); } @@ -50,7 +159,12 @@ impl ExecutedToolCalls { .iter() .filter_map(ResponseItem::id) .collect::>(); - state.direct_calls.retain(|id, _| output_ids.contains(id)); + for (_, call) in state + .direct_calls + .extract_if(|id, _| !output_ids.contains(id)) + { + ResultBodyTurn::discard(&state.body_turn, call.tool_result_id()); + } } Self::attach_pending_to_prompt_with_state(state, items, retry_cache, request_kind); } 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 1a3a1a25ef..50114526f5 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 @@ -11,6 +11,15 @@ use serde_json::json; use super::*; impl ExecutedToolCalls { + fn record_tool_result_metadata( + &self, + source: &ToolCallSource, + call_id: &str, + metadata: &JsonValue, + ) -> bool { + self.record_result_metadata(source, call_id, ToolResultMetadata::new(metadata)) + } + fn attach_pending_to_prompt( &self, items: &mut [ResponseItem], @@ -489,13 +498,13 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss panic!("recording must not rebuild the tool result") } - fn tool_result_metadata(&self) -> Option<&JsonValue> { + fn tool_result_metadata(&self) -> ToolResultMetadata { assert!( self.2.state.try_lock().is_ok(), "result callbacks must run unlocked" ); self.0.set(self.0.get() + 1); - Some(&self.1) + ToolResultMetadata::new(&self.1) } } diff --git a/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs b/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs index 7514674d39..1262fa03a0 100644 --- a/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs +++ b/codex-rs/core/src/tools/executed_tool_calls_direct_tests.rs @@ -1,6 +1,11 @@ //! Tests Direct metadata admission and permit lifetimes. //! Metadata limits must leave ordinary tool outputs unchanged. +use codex_login::AuthHeaders; +use codex_login::CodexAuth; +use codex_login::ExternalAuth; +use codex_login::ExternalAuthFuture; +use codex_login::ExternalAuthRefreshContext; use codex_protocol::ResponseItemId; use codex_protocol::models::FunctionCallOutputPayload; use codex_protocol::models::ResponseInputItem; @@ -8,6 +13,8 @@ use pretty_assertions::assert_eq; use serde_json::json; use super::*; +use crate::session::turn_context::TurnContext; +use codex_login::AuthManager; fn output(call_id: &str) -> ResponseItem { ResponseItem::from(ResponseInputItem::FunctionCallOutput { @@ -16,6 +23,36 @@ fn output(call_id: &str) -> ResponseItem { }) } +#[test] +fn capture_only_does_not_publish_general_direct_metadata_after_refresh() { + let mut features = Features::default(); + features.enable(Feature::ConnectorToolResultPassthrough); + let recorder = ExecutedToolCalls::new(&features, &InitialHistory::New); + for enabled in [false, true, false] { + let permit = recorder.reserve_direct_call().unwrap(); + features.set_enabled(Feature::ExecutedToolCallMetadata, enabled); + recorder.refresh(&features); + let mut item = output("shell"); + let original = item.clone(); + let call = ExecutedToolCall::new("exec_command".into(), json!({"cmd": "pwd"})); + recorder.attach_direct_call_to_output( + &mut item, + Some((call.clone(), permit)), + &codex_protocol_test_support::uuid_v7_item_id_generator_for_test(), + ); + if enabled { + assert_eq!( + item.executed_tool_call_metadata() + .and_then(|metadata| metadata.executed_tool_calls.as_ref()), + Some(&vec![call]), + ); + } else { + assert_eq!(item, original); + } + assert_eq!(recorder.pending_direct_calls.load(Ordering::Relaxed), 0); + } +} + #[test] fn direct_request_uses_live_window_after_persisted_budget_is_exhausted() { let mut features = Features::default(); @@ -70,6 +107,168 @@ fn direct_request_uses_live_window_after_persisted_budget_is_exhausted() { assert!(after_refresh[0].executed_tool_call_metadata().is_none()); } +pub(super) async fn connector_result_turn() -> TurnContext { + let (_, mut turn) = crate::session::tests::make_session_and_context().await; + let manager = + AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing()); + turn.provider = codex_model_provider::create_model_provider( + codex_model_provider_info::ModelProviderInfo::create_openai_provider( + /*base_url*/ None, + ), + Some(Arc::clone(&manager)), + ); + turn.auth_manager = Some(manager); + Arc::make_mut(&mut turn.config) + .features + .enable(Feature::ConnectorToolResultPassthrough) + .unwrap(); + turn +} + +#[test_case::test_case(1, 600 * 1024; "byte limit")] +#[test_case::test_case(MAX_PENDING_EXECUTED_TOOL_CALLS, 1; "count limit")] +#[tokio::test] +async fn direct_result_bodies_require_the_originating_output_turn_and_owner( + capacity: usize, + text_bytes: usize, +) -> anyhow::Result<()> { + struct SelectedAuth(CodexAuth); + + impl ExternalAuth for SelectedAuth { + fn resolve(&self) -> ExternalAuthFuture<'_, CodexAuth> { + Box::pin(async { Ok(self.0.clone()) }) + } + + fn refresh( + &self, + _context: ExternalAuthRefreshContext, + ) -> ExternalAuthFuture<'_, CodexAuth> { + self.resolve() + } + } + + let hosted = |token| { + let mut headers = http::HeaderMap::new(); + headers.insert("authorization", http::HeaderValue::from_static(token)); + headers.insert("chatgpt-account-id", "workspace-a".parse().unwrap()); + CodexAuth::Headers(AuthHeaders::new(headers)) + }; + let mut turn = connector_result_turn().await; + // Overflow keeps ordinary metadata under its separate rollout. + Arc::make_mut(&mut turn.config) + .features + .enable(Feature::ExecutedToolCallMetadata) + .unwrap(); + let recorder = ExecutedToolCalls::new(&turn.config.features, &InitialHistory::New); + let manager = Arc::clone(turn.auth_manager.as_ref().unwrap()); + let provider = turn.provider.info().clone(); + for config in [ + json!({"auth": {"command": "get-token"}}), + json!({"requires_openai_auth": true, "base_url": "https://example.com/backend-api/codex"}), + json!({"requires_openai_auth": true, "http_headers": {"aUtHoRiZaTiOn": "independent"}}), + json!({"requires_openai_auth": true, "env_http_headers": {"Authorization": "TEST_MODEL_TOKEN"}}), + json!({"requires_openai_auth": true, "query_params": {"api-key": "alternate"}}), + ] { + turn.provider = codex_model_provider::create_model_provider( + serde_json::from_value(config)?, + Some(Arc::clone(&manager)), + ); + assert!(recorder.begin_turn(&turn).is_none()); + } + turn.provider = + codex_model_provider::create_model_provider(provider, Some(Arc::clone(&manager))); + let capture = recorder.begin_turn(&turn).unwrap(); + let generation = manager + .auth_change_state_receiver() + .borrow() + .owner_generation; + let owner = manager.auth_owner(); + let bodies = |items: &[ResponseItem]| capture.for_input(items, &owner); + + let body = json!({"content": [{"type": "text", "text": "x".repeat(text_bytes)}]}); + let result = serde_json::from_value(body.clone())?; + let metadata = json!({"provider": "observed"}); + let attach = |id: &str| { + let mut call = ExecutedToolCall::new("read".into(), json!({"id": id})); + call.set_tool_result_metadata( + ToolResultMetadata::new(&metadata).with_result_id(capture.record(&result)), + ); + let mut item = output(id); + recorder.attach_direct_call_to_output( + &mut item, + Some((call, recorder.reserve_direct_call().unwrap())), + &codex_protocol_test_support::uuid_v7_item_id_generator_for_test(), + ); + item + }; + let mut history: Vec<_> = (0..=capacity).map(|i| attach(&i.to_string())).collect(); + assert_eq!( + recorder.lock_state().as_ref().unwrap().direct_calls.len(), + history.len().min(MAX_PENDING_EXECUTED_TOOL_CALLS) + ); + recorder.attach_to_prompt(&mut history, &mut HashMap::new()); + let selected = bodies(&history[..capacity]); + assert_eq!(selected.len(), capacity); + assert_eq!( + serde_json::from_str::(selected[0].2.as_json())?, + body + ); + assert!(bodies(&history[capacity..]).is_empty()); + let overflow = serde_json::to_value(&history[capacity])?; + assert_eq!(overflow["output"], "tool result"); + assert_eq!( + overflow["internal_chat_message_metadata_passthrough"]["executed_tool_calls"], + json!([{ + "name": "read", + "arguments": {"id": capacity.to_string()}, + "tool_result_metadata": metadata, + }]) + ); + + recorder.attach_to_prompt(&mut history[1..], &mut HashMap::new()); + let history = [ + history[0].clone(), + attach("replacement"), + attach("over-cap"), + ]; + assert!(matches!(bodies(&history).as_slice(), [(1, 0, _)])); + let mut foreign = [output("replacement")]; + foreign[0].set_id(history[1].id().cloned()); + recorder.attach_to_prompt(&mut foreign, &mut HashMap::new()); + assert!(bodies(&foreign).is_empty()); + assert!(matches!(bodies(&history).as_slice(), [(1, 0, _)])); + + let other_manager = AuthManager::from_auth_for_testing(manager.auth_cached().unwrap()); + assert_eq!( + other_manager + .auth_change_state_receiver() + .borrow() + .owner_generation, + generation + ); + assert!( + capture + .for_input(&history, &other_manager.auth_owner()) + .is_empty() + ); + // Switching away and back invalidates the request's original owner generation. + for auth in [hosted("Bearer rotated"), manager.auth_cached().unwrap()] { + manager + .set_external_auth(Arc::new(SelectedAuth(auth))) + .await?; + } + assert!(bodies(&history).is_empty()); + let finished = Arc::downgrade(&capture); + drop(capture); + assert!(finished.upgrade().is_none()); + + // The next turn starts with an empty result store. + turn.sub_id = "next".into(); + let next = recorder.begin_turn(&turn).unwrap(); + assert!(next.for_input(&history, &manager.auth_owner()).is_empty()); + Ok(()) +} + #[test] fn direct_metadata_follows_output_ids_with_reused_call_ids_and_reverse_completion() { for supplied_ids in [false, true] { diff --git a/codex-rs/core/src/tools/handlers/mcp.rs b/codex-rs/core/src/tools/handlers/mcp.rs index b386b3e895..3720c23a15 100644 --- a/codex-rs/core/src/tools/handlers/mcp.rs +++ b/codex-rs/core/src/tools/handlers/mcp.rs @@ -300,6 +300,8 @@ impl McpHandler { .map(TruncationPolicy::Tokens) .unwrap_or(step_context.settings.model_info.truncation_policy.into()); let started = Instant::now(); + let recorder = &session.services.executed_tool_calls; + let mut result_capture = None; // Bound the compiler's async-layout query depth for approval and dispatch. let result = Box::pin(handle_mcp_tool_call( Arc::clone(&session), @@ -313,6 +315,13 @@ impl McpHandler { tool_name, &source, payload, + |call, raw| { + if result_metadata_capture_allowed + && !matches!(source, ToolCallSource::CodeMode { .. }) + { + result_capture = recorder.capture_mcp_result(&step_context.turn, call, raw); + } + }, )) .await; @@ -327,6 +336,7 @@ impl McpHandler { result, tool_input, result_metadata_capture_allowed, + result_capture, wall_time: started.elapsed(), original_image_detail_supported: can_request_original_image_detail( &step_context.settings.model_info, @@ -833,6 +843,7 @@ mod tests { } }), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: Duration::from_millis(42), original_image_detail_supported: true, truncation_policy: codex_utils_output_truncation::TruncationPolicy::Bytes(1024), diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs index 48626515e9..26acb5add3 100644 --- a/codex-rs/core/src/tools/parallel.rs +++ b/codex-rs/core/src/tools/parallel.rs @@ -39,7 +39,6 @@ use codex_extension_api::ToolCallOutcome; use codex_history::ResponseItemEnvelope; use codex_protocol::error::CodexErr; use codex_protocol::models::ResponseInputItem; -use codex_protocol::models::ToolResultMetadata; struct ToolCallTimingGuard { started_at: Option, @@ -176,10 +175,8 @@ impl ToolCallRuntime { 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)); + if let Some((call, _)) = recorded_call.as_mut() { + call.set_tool_result_metadata(result.result.tool_result_metadata()); } result.into_response(file_backed_tool_audio) } diff --git a/codex-rs/core/src/tools/registry.rs b/codex-rs/core/src/tools/registry.rs index efc7508aae..0fb085f522 100644 --- a/codex-rs/core/src/tools/registry.rs +++ b/codex-rs/core/src/tools/registry.rs @@ -37,6 +37,7 @@ use codex_history::ResponseItemEnvelope; use codex_protocol::models::FunctionCallOutputPayload; use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; +use codex_protocol::models::ToolResultMetadata; use codex_protocol::parse_command::ParsedCommand; use codex_protocol::protocol::EventMsg; use codex_rollout::state_db; @@ -392,7 +393,7 @@ impl ToolOutput for PostToolUseFeedbackOutput { self.original.code_mode_result(payload) } - fn tool_result_metadata(&self) -> Option<&Value> { + fn tool_result_metadata(&self) -> ToolResultMetadata { self.original.tool_result_metadata() } } diff --git a/codex-rs/core/src/tools/registry_tests.rs b/codex-rs/core/src/tools/registry_tests.rs index 01ce0a6e3a..bea6358e8c 100644 --- a/codex-rs/core/src/tools/registry_tests.rs +++ b/codex-rs/core/src/tools/registry_tests.rs @@ -627,6 +627,7 @@ fn post_tool_use_feedback_output_preserves_fallback_token_limit_override( }, tool_input: serde_json::json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: Duration::ZERO, original_image_detail_supported: false, truncation_policy, @@ -675,6 +676,7 @@ fn mcp_audio_producer_limit_is_transient_until_history_admission(file_backed_too }, tool_input: serde_json::json!({}), result_metadata_capture_allowed: false, + result_capture: Default::default(), wall_time: Duration::ZERO, original_image_detail_supported: false, truncation_policy: TruncationPolicy::Tokens(100), @@ -768,6 +770,7 @@ fn post_tool_use_feedback_output_preserves_mcp_result_metadata(tool_error: bool) }, tool_input: serde_json::json!({ "query": "rewritten query" }), result_metadata_capture_allowed: true, + result_capture: Default::default(), wall_time: std::time::Duration::ZERO, original_image_detail_supported: false, truncation_policy: codex_utils_output_truncation::TruncationPolicy::Bytes(64), @@ -781,7 +784,10 @@ fn post_tool_use_feedback_output_preserves_mcp_result_metadata(tool_error: bool) arguments: "{}".to_string(), }; let original_result = result.original.code_mode_result(&payload); - assert_eq!(result.tool_result_metadata(), Some(&metadata)); + assert_eq!( + result.tool_result_metadata(), + ToolResultMetadata::new(&metadata) + ); assert_eq!(result.code_mode_result(&payload), original_result); } diff --git a/codex-rs/core/tests/common/apps_test_server.rs b/codex-rs/core/tests/common/apps_test_server.rs index b51231602a..6db166edb3 100644 --- a/codex-rs/core/tests/common/apps_test_server.rs +++ b/codex-rs/core/tests/common/apps_test_server.rs @@ -370,8 +370,10 @@ pub async fn recorded_apps_tool_calls(server: &MockServer) -> Vec { .into_iter() .filter_map(|request| { let body: Value = serde_json::from_slice(&request.body).ok()?; - (request.url.path() == "/api/codex/ps/mcp" - && body.get("method").and_then(Value::as_str) == Some("tools/call")) + (matches!( + request.url.path(), + "/api/codex/ps/mcp" | "/backend-api/ps/mcp" + ) && body.get("method").and_then(Value::as_str) == Some("tools/call")) .then_some(body) }) .collect() diff --git a/codex-rs/core/tests/suite/direct_tool_metadata.rs b/codex-rs/core/tests/suite/direct_tool_metadata.rs index 8656e538e8..1a3e4439f7 100644 --- a/codex-rs/core/tests/suite/direct_tool_metadata.rs +++ b/codex-rs/core/tests/suite/direct_tool_metadata.rs @@ -14,6 +14,8 @@ use core_test_support::apps_test_server::SEARCH_CALENDAR_NAMESPACE; use core_test_support::apps_test_server::recorded_apps_tool_calls; use core_test_support::apps_test_server::search_capable_apps_builder; use core_test_support::responses::ev_function_call_with_namespace; +use core_test_support::runtime_auth::PROBE_SERVER; +use core_test_support::runtime_auth::run_harness_through_proxy; use core_test_support::wait_for_mcp_server; use wiremock::Mock; use wiremock::Request; @@ -54,6 +56,190 @@ pub(super) fn tool_call_metadata(mut item: Value) -> Value { metadata } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn local_direct_connector_result_is_sent_only_on_its_originating_turn() -> Result<()> { + skip_if_no_network!(Ok(())); + if std::env::var_os(PROBE_SERVER).is_some() { + let mut builder = + search_capable_apps_builder(codex_model_provider::DEFAULT_CHATGPT_BASE_URL) + .with_config(|config| { + config.model_provider.base_url = + Some(codex_model_provider_info::CHATGPT_CODEX_BASE_URL.to_owned()); + config.model_provider.include_internal_metadata = true; + config.analytics_enabled = Some(true); + config + .features + .enable(Feature::ConnectorToolResultPassthrough) + .unwrap(); + for feature in [ + Feature::ExecutedToolCallMetadata, + Feature::CodeMode, + Feature::CodeModeOnly, + ] { + config.features.disable(feature).unwrap(); + } + }); + let fixture = start_mock_server().await; + let test = builder.build(&fixture).await?; + assert!(test.codex.analytics_enabled()); + wait_for_mcp_server(&test.codex, CODEX_APPS_MCP_SERVER_NAME).await?; + test.submit_turn("List events in [$calendar](app://calendar)") + .await?; + test.submit_turn("Continue").await?; + test.codex.shutdown_and_wait().await?; + return Ok(()); + } + + let server = start_mock_server().await; + AppsTestServer::mount(&server).await?; + let call = ev_function_call_with_namespace( + "list-events", + SEARCH_CALENDAR_NAMESPACE, + SEARCH_CALENDAR_LIST_TOOL, + r#"{"query":"today"}"#, + ); + let responses = mount_sse_sequence( + &server, + vec![ + sse(vec![call, ev_completed("first")]), + sse(vec![ev_completed("followup")]), + sse(vec![ev_completed("next")]), + ], + ) + .await; + const TEST_NAME: &str = "suite::direct_tool_metadata::local_direct_connector_result_is_sent_only_on_its_originating_turn"; + run_harness_through_proxy(&server, TEST_NAME, /*realtime_target*/ None).await?; + let requests = responses.requests(); + assert_eq!(requests.len(), 3); + let rpcs = recorded_apps_tool_calls(&server).await; + assert_eq!(rpcs.len(), 1); + let output = requests[1].function_call_output("list-events"); + let row = "/internal_chat_message_metadata_passthrough/executed_tool_calls/0/tool_result"; + assert_eq!( + output.pointer(row), + Some(&json!({ + "content": [{"type": "text", "text": "called calendar_list_events for at with "}], + "structuredContent": {"_codex_apps": rpcs[0]["params"]["_meta"]["_codex_apps"]}, + })) + ); + let replay = requests[2].function_call_output("list-events"); + assert_eq!(replay["output"], output["output"]); + assert!(replay.pointer(row).is_none()); + Ok(()) +} + +#[cfg_attr(windows, ignore = "no exec_command on Windows")] +#[test_case(false; "http")] +#[test_case(true; "websocket")] +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn connector_capture_does_not_publish_shell_metadata(websocket: bool) -> Result<()> { + skip_if_no_network!(Ok(())); + let mut builder = test_codex().with_config(|config| { + config + .features + .disable(Feature::CodeMode) + .expect("disable code mode"); + config + .features + .disable(Feature::CodeModeOnly) + .expect("disable code-mode-only tools"); + config + .features + .enable(Feature::UnifiedExec) + .expect("enable unified exec"); + config + .features + .disable(Feature::ExecutedToolCallMetadata) + .expect("disable tool-call metadata"); + config + .features + .enable(Feature::ConnectorToolResultPassthrough) + .expect("enable connector result passthrough"); + }); + let call = |id| { + let mut call = ev_function_call( + id, + "exec_command", + r#"{"cmd":"echo connector-capture-shell-marker"}"#, + ); + call["item"]["id"] = json!(format!("fc_{id}")); + call + }; + let events = vec![ + vec![ + ev_response_created("shell"), + call("shell-only"), + ev_completed("shell"), + ], + vec![ + ev_response_created("second-shell"), + call("second-shell"), + ev_completed("second-shell"), + ], + vec![ev_response_created("done"), ev_completed("done")], + ]; + let http_server = if websocket { + None + } else { + Some(start_mock_server().await) + }; + let http_mock = if let Some(server) = &http_server { + Some(mount_sse_sequence(server, events.iter().cloned().map(sse).collect()).await) + } else { + None + }; + let websocket_server = if websocket { + let mut responses = vec![vec![ev_response_created("warmup"), ev_completed("warmup")]]; + responses.extend(events); + Some(start_websocket_server(vec![responses]).await) + } else { + None + }; + let test = if let Some(server) = &websocket_server { + builder.build_with_websocket_server(server).await? + } else { + builder + .build_with_auto_env(http_server.as_ref().expect("HTTP test server")) + .await? + }; + test.submit_turn("Run the shell command").await?; + let request = if let Some(server) = &websocket_server { + let connection = server.single_connection(); + assert_eq!(connection.len(), 4); + assert_eq!(connection[2].body_json()["previous_response_id"], "shell"); + let request = connection[3].body_json(); + assert_eq!(request["previous_response_id"], "second-shell"); + request + } else { + let requests = http_mock + .as_ref() + .expect("HTTP response sequence") + .requests(); + assert_eq!(requests.len(), 3); + requests[2].body_json() + }; + let outputs = request["input"] + .as_array() + .expect("follow-up input") + .iter() + .filter(|item| item["type"] == "function_call_output") + .collect::>(); + assert_eq!(outputs.len(), if websocket { 1 } else { 2 }); + for output in outputs { + assert!( + output["output"] + .to_string() + .contains("connector-capture-shell-marker") + ); + assert_eq!(tool_call_metadata(output.clone()), json!({})); + } + test.codex.shutdown_and_wait().await?; + if let Some(server) = websocket_server { + server.shutdown().await; + } + Ok(()) +} + #[test_case(false; "http")] #[test_case(true; "websocket")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] diff --git a/codex-rs/core/tests/suite/tool_lifecycle.rs b/codex-rs/core/tests/suite/tool_lifecycle.rs index 60317b806e..c23404ee36 100644 --- a/codex-rs/core/tests/suite/tool_lifecycle.rs +++ b/codex-rs/core/tests/suite/tool_lifecycle.rs @@ -20,6 +20,8 @@ use codex_extension_api::ToolLifecycleContributor; use codex_extension_api::ToolLifecycleFuture; use codex_extension_api::ToolStartInput; use codex_features::Feature; +use codex_login::AuthHeaders; +use codex_login::CodexAuth; use codex_mcp::CODEX_APPS_MCP_SERVER_NAME; use codex_protocol::mcp::CallToolResult; use codex_protocol::models::ContentItem; @@ -369,12 +371,19 @@ async fn mcp_result_processing_precedes_completion( let server = responses::start_mock_server().await; let apps_server = AppsTestServer::mount(&server).await?; - let server_result: CallToolResult = serde_json::from_value(json!({ + let mut server_result: CallToolResult = serde_json::from_value(json!({ "content": [{"type": "text", "text": "server result"}], "structuredContent": {"text": "server result"}, "isError": false, "_meta": {"private-mcp-metadata": "server"}, }))?; + let unsupported_audio = matches!(processing, McpResultProcessing::Unchanged); + if unsupported_audio { + server_result.structured_content = None; + server_result + .content + .push(json!({"type": "audio", "data": "YQ==", "mimeType": "audio/wav"})); + } let response_result = server_result.clone(); Mock::given(body_partial_json(json!({"method": "tools/call"}))) .respond_with(move |request: &Request| { @@ -400,7 +409,12 @@ async fn mcp_result_processing_precedes_completion( }))?) } }; - let expected_result = replacement.clone().unwrap_or_else(|| server_result.clone()); + let mut expected_result = replacement.clone().unwrap_or_else(|| server_result.clone()); + if unsupported_audio { + expected_result.content[1] = json!({ + "type": "text", "text": "