Pass eligible connector results through to ChatGPT Responses (#62392)

## What changed

Add the off-by-default `features.connector_tool_result_passthrough` flag. For direct ChatGPT Apps calls, capture eligible text and structured content from the original MCP result before tool output processing. Attach the captured body to the matching executed-tool record on follow-up HTTP Responses requests to the ChatGPT Codex endpoint when the request uses the same authenticated account and turn.

Bound captured bodies in memory for the originating turn. Enabling passthrough alone scopes executed-tool metadata to calls with a captured result ID.

## Testing

Add coverage for same-turn HTTP delivery, omission on later turns or after an account change, and omission of shell-call metadata on HTTP and WebSocket requests when only passthrough is enabled.

GitOrigin-RevId: 410c81559bfc15022b896cf006cb631f3fd9454e
This commit is contained in:
ssetty-oai
2026-11-19 01:27:01 +00:00
committed by copyberry
parent b5e1f3ae9d
commit d1d1ba0b83
25 changed files with 1181 additions and 51 deletions
+39
View File
@@ -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
+6
View File
@@ -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"
},
+116 -2
View File
@@ -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<AuthOwner> {
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<Prompt>,
) -> Arc<Prompt> {
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<AuthOwner>,
input: &[ResponseItem],
) -> Vec<(usize, usize, Arc<ToolResultBody>)> {
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| {
+90 -3
View File
@@ -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<InferenceTraceAttempt> {
fn inference_trace_fixture(
temp: &TempDir,
) -> anyhow::Result<(Arc<TraceWriter>, 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<InferenceTraceAtt
"gpt-test".to_string(),
"test-provider".to_string(),
);
let attempt = inference_trace.start_attempt();
Ok((writer, inference_trace.start_attempt()))
}
fn started_inference_attempt(temp: &TempDir) -> anyhow::Result<InferenceTraceAttempt> {
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<InferenceTraceAtt
Ok(attempt)
}
#[tokio::test]
async fn prepared_prompt_trace_respects_connector_only_capture() -> 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,
+5
View File
@@ -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<CompletedMcpToolCall, FunctionCallError> {
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<CompletedMcpToolCall, FunctionCallError> {
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,
@@ -175,6 +175,7 @@ impl<'call> ToolExecutor<ToolCall<'call>> 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,
+4
View File
@@ -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),
+16 -3
View File
@@ -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<Arc<PendingResultBody>>,
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<JsonValue> {
+4
View File
@@ -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,
+264 -22
View File
@@ -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<ResponseItem>, String), Vec<ExecutedToolCall>>;
@@ -59,11 +69,134 @@ type ExecutedToolCallCache =
#[derive(Clone, Default)]
pub(crate) struct ExecutedToolCalls {
state: Arc<Mutex<Option<ExecutedToolCallRecorderState>>>,
captures_result_bodies: bool,
retained_direct_metadata_bytes: Arc<AtomicUsize>,
pending_direct_calls: Arc<AtomicUsize>,
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<TurnMetadataState>,
owner: AuthOwner,
auth_mode: AuthMode,
retained: Mutex<RetainedResultBodies>,
}
#[derive(Default)]
struct RetainedResultBodies {
by_id: HashMap<Uuid, Arc<ToolResultBody>>,
bytes: usize,
}
/// Refund the provisional slot when a callback blocks or the call is cancelled.
#[derive(Debug)]
pub(crate) struct PendingResultBody {
turn: Weak<ResultBodyTurn>,
id: Uuid,
accepted: AtomicBool,
}
impl PendingResultBody {
fn record(turn: &Arc<ResultBodyTurn>, result: &CallToolResult) -> Option<Arc<Self>> {
Some(Arc::new(Self {
id: turn.record(result)?,
turn: Arc::downgrade(turn),
accepted: AtomicBool::new(false),
}))
}
pub(super) fn accept(&self) -> Option<Uuid> {
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<Self>, call: &mut ExecutedToolCall) {
Self::discard(turn, call.tool_result_id());
call.clear_tool_result_id();
}
fn discard(turn: &Weak<Self>, id: Option<Uuid>) {
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<Uuid> {
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<ToolResultBody>)> {
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<ResponseItemId, ExecutedToolCall>,
body_turn: Weak<ResultBodyTurn>,
cells: HashMap<CellId, RecordedCell>,
output_cells: HashMap<String, CellId>,
retained_calls: HashMap<(std::mem::Discriminant<ResponseItem>, 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<Arc<ResultBodyTurn>> {
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<Arc<ResultBodyTurn>> {
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<Arc<PendingResultBody>> {
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) {
@@ -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::<HashSet<_>>();
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);
}
@@ -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)
}
}
@@ -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::<JsonValue>(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] {
+11
View File
@@ -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),
+2 -5
View File
@@ -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<Instant>,
@@ -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)
}
+2 -1
View File
@@ -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()
}
}
+7 -1
View File
@@ -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);
}
@@ -370,8 +370,10 @@ pub async fn recorded_apps_tool_calls(server: &MockServer) -> Vec<Value> {
.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()
@@ -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::<Vec<_>>();
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)]
+44 -3
View File
@@ -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": "<audio content omitted because you do not support audio input>",
});
}
let (entered_tx, entered_rx) = oneshot::channel();
let contributor = Arc::new(BlockingMcpResultContributor {
entered: Mutex::new(Some(entered_tx)),
@@ -409,11 +423,27 @@ async fn mcp_result_processing_precedes_completion(
});
let mut extensions = ExtensionRegistryBuilder::<Config>::new();
extensions.tool_lifecycle_contributor(contributor.clone());
let mut headers = http::HeaderMap::new();
headers.insert("authorization", "Bearer session-token".parse()?);
headers.insert("chatgpt-account-id", "account_id".parse()?);
let test = apps_enabled_builder(apps_server.chatgpt_base_url)
.with_auth(CodexAuth::Headers(AuthHeaders::new(headers)))
.with_extensions(Arc::new(extensions.build()))
.with_config(move |config| {
if matches!(mode, McpCallMode::CodeMode) {
let _ = config.features.enable(Feature::CodeMode);
} else {
config.model_provider.include_internal_metadata = true;
config.model_provider.requires_openai_auth = true;
let passthrough = Feature::ConnectorToolResultPassthrough;
config
.features
.enable(passthrough)
.expect("enable connector result passthrough");
config
.features
.enable(Feature::ExecutedToolCallMetadata)
.expect("enable tool-call metadata");
}
})
.build_with_auto_env(&server)
@@ -491,10 +521,21 @@ async fn mcp_result_processing_precedes_completion(
McpCallMode::Direct => request.function_call_output(call_id),
McpCallMode::CodeMode => request.custom_tool_call_output(call_id),
};
if matches!(mode, McpCallMode::Direct) {
let call = &output["internal_chat_message_metadata_passthrough"]["executed_tool_calls"][0];
assert!(
call.get("tool_result").is_none(),
"custom Responses destination"
);
assert_eq!(call["tool_result_metadata"], json!(expected_result.meta));
}
let output = output["output"].to_string();
assert!(
output.contains(
expected_result.content[0]["text"]
expected_result
.content
.last()
.context("fixture should contain content")?["text"]
.as_str()
.expect("fixture should contain text")
)
+8
View File
@@ -149,6 +149,8 @@ pub enum Feature {
UntrustedAsToolOutput,
/// Record model-attempted tool calls in internal Responses metadata.
ExecutedToolCallMetadata,
/// Record executed tool calls and attach eligible connector results to their metadata.
ConnectorToolResultPassthrough,
/// Enable JavaScript code mode backed by the standalone host process.
CodeMode,
/// Expose ranked tool discovery inside JavaScript code mode.
@@ -1327,6 +1329,12 @@ pub const FEATURES: &[FeatureSpec] = &[
stage: Stage::UnderDevelopment,
default_enabled: false,
},
FeatureSpec {
id: Feature::ConnectorToolResultPassthrough,
key: "connector_tool_result_passthrough",
stage: Stage::UnderDevelopment,
default_enabled: false,
},
FeatureSpec {
id: Feature::StableEnvironmentTools,
key: "stable_environment_tools",
+28
View File
@@ -464,6 +464,34 @@ impl RmcpClient {
self.protocol_mode
}
/// Matches the registered HTTP route and header configuration after dispatch.
/// A client that selected stored OAuth during session recovery no longer qualifies.
pub fn matches_result_body_source(
&self,
require_runtime_auth: bool,
expected_url: &str,
expected_headers: Option<&HashMap<String, String>>,
expected_env_headers: Option<&HashMap<String, String>>,
) -> bool {
let TransportRecipe::StreamableHttp {
url,
auth_provider,
bearer_token: None,
http_headers,
env_http_headers,
pinned_credential_store,
..
} = &self.transport_recipe
else {
return false;
};
(!require_runtime_auth || auth_provider.is_some())
&& pinned_credential_store.get().is_none()
&& url == expected_url
&& http_headers.as_ref() == expected_headers
&& env_http_headers.as_ref() == expected_env_headers
}
pub async fn new_in_process_client(
factory: Arc<dyn InProcessTransportFactory>,
) -> io::Result<Self> {
@@ -106,6 +106,13 @@ async fn recovery_retains_originator_without_initial_credentials() -> anyhow::Re
call_echo_tool(&client, "recovered").await?,
expected_echo_result("recovered")
);
assert_eq!(
client.matches_result_body_source(
/*require_runtime_auth*/ false, &url, /*expected_headers*/ None,
/*expected_env_headers*/ None,
),
recovery == 0
);
}
let snapshot = metrics.snapshot()?;
+6 -1
View File
@@ -166,9 +166,14 @@ impl InferenceTraceAttempt {
}
}
/// Whether this attempt records inference payloads.
pub fn is_enabled(&self) -> bool {
matches!(&self.state, InferenceTraceAttemptState::Enabled(_))
}
/// Whether terminal trace records need the completed output items.
pub fn needs_output_items(&self) -> bool {
matches!(&self.state, InferenceTraceAttemptState::Enabled(_))
self.is_enabled()
}
fn inference_call_id(&self) -> Option<&str> {
+5 -4
View File
@@ -4,6 +4,7 @@ use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ImageReference;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ToolResultMetadata;
use codex_utils_path_uri::PathUri;
use serde_json::Value as JsonValue;
@@ -79,9 +80,9 @@ pub trait ToolOutput: Send {
response_input_to_code_mode_result(self.to_response_item("", payload))
}
/// Borrows original host-only metadata for recording, not for model output or logging.
fn tool_result_metadata(&self) -> Option<&JsonValue> {
None
/// Returns the host-observed result fields for executed-tool passthrough.
fn tool_result_metadata(&self) -> ToolResultMetadata {
ToolResultMetadata::default()
}
}
@@ -141,7 +142,7 @@ where
(**self).code_mode_result(payload)
}
fn tool_result_metadata(&self) -> Option<&JsonValue> {
fn tool_result_metadata(&self) -> ToolResultMetadata {
(**self).tool_result_metadata()
}
}