Lightweight coding agent that runs in your terminal
Rust
Record result sources in app tool analytics (#42164)
ningyi-oai12ed76b09bf3
diff --git a/codex-rs/config/src/config_requirements.rs b/codex-rs/config/src/config_requirements.rsindex 0b6785b594..8fbeed6b48 100644--- a/codex-rs/config/src/config_requirements.rs+++ b/codex-rs/config/src/config_requirements.rs@@ -14,8 +14,10 @@ use serde::de::value::Error as ValueDeserializerError;use serde::de::value::StrDeserializer;use std::collections::BTreeMap;use std::collections::BTreeSet;+use std::convert::Infallible;use std::fmt;use std::path::PathBuf;+use std::str::FromStr;use wildmatch::WildMatchPattern;use super::requirements_exec_policy::RequirementsExecPolicyToml;@@ -822,11 +824,53 @@ impl FeatureRequirementsToml {#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]pub struct AppToolRequirementToml {pub approval_mode: Option<AppToolApproval>,+ /// Opt-in analytics extraction for this exact tool, not a tool argument.+ /// The highest-priority rule wins as a whole, including unsupported formats.+ pub analytics_result_source: Option<AppToolResultSourceRequirementToml>,+}++#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]+#[serde(deny_unknown_fields)]+pub struct AppToolResultSourceRequirementToml {+ /// Result format to parse; currently only `detailed_message_search_v1` is supported.+ pub format: AppToolResultSourceFormat,+ /// Source kind emitted alongside each extracted ID.+ #[serde(rename = "type")]+ pub source_type: String,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum AppToolResultSourceFormat {+ DetailedMessageSearchV1,+ /// Keep unknown formats so higher-priority rules still override lower ones.+ Unknown(String),+}++impl FromStr for AppToolResultSourceFormat {+ type Err = Infallible;++ fn from_str(value: &str) -> Result<Self, Self::Err> {+ Ok(match value {+ "detailed_message_search_v1" => Self::DetailedMessageSearchV1,+ _ => Self::Unknown(value.to_string()),+ })+ }+}++impl<'de> Deserialize<'de> for AppToolResultSourceFormat {+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>+ where+ D: serde::Deserializer<'de>,+ {+ String::deserialize(deserializer)?+ .parse()+ .map_err(D::Error::custom)+ }}impl AppToolRequirementToml {pub fn is_empty(&self) -> bool {- self.approval_mode.is_none()+ self.approval_mode.is_none() && self.analytics_result_source.is_none()}}@@ -897,6 +941,9 @@ pub(crate) fn merge_app_requirements_descending(if base_tool.approval_mode.is_none() {base_tool.approval_mode = incoming_tool.approval_mode;}+ if base_tool.analytics_result_source.is_none() {+ base_tool.analytics_result_source = incoming_tool.analytics_result_source;+ }}}}@@ -3093,6 +3140,7 @@ allowed_approvals_reviewers = ["user"]"calendar/list_events".to_string(),AppToolRequirementToml {approval_mode: Some(AppToolApproval::Approve),+ analytics_result_source: None,},)]),}),@@ -3103,6 +3151,56 @@ allowed_approvals_reviewers = ["user"]Ok(())}+ #[test]+ fn app_tool_result_source_requirements_parse_and_merge() -> Result<()> {+ let rule = r#"+ [apps.connector_123123.tools."messages/search"]+ analytics_result_source = { format = "detailed_message_search_v1", type = "message_room" }+ "#;+ let requirements: ConfigRequirementsToml = from_str(rule)?;+ assert!(!requirements.is_empty());+ let source = requirements.apps.expect("apps should be present");++ for higher_rule in [+ None,+ Some(("unsupported", "other_resource")),+ Some(("detailed_message_search_v1", "other_resource")),+ ] {+ let mut merged = source.clone();+ merged+ .apps+ .get_mut("connector_123123")+ .expect("app should be present")+ .tools+ .as_mut()+ .expect("tools should be present")+ .tools+ .get_mut("messages/search")+ .expect("tool should be present")+ .analytics_result_source = higher_rule.map(|(format, source_type)| {+ from_str(&format!("format = {format:?}\ntype = {source_type:?}"))+ .expect("complete source rule should parse, including unknown formats")+ });+ let expected = if higher_rule.is_none() {+ source.clone()+ } else {+ merged.clone()+ };++ merge_app_requirements_descending(&mut merged, source.clone());++ assert_eq!(merged, expected);+ }++ for incomplete_rule in [+ r#"format = "detailed_message_search_v1""#,+ r#"type = "message_room""#,+ ] {+ assert!(from_str::<AppToolResultSourceRequirementToml>(incomplete_rule).is_err());+ }+ Ok(())+ }+fn apps_requirements(entries: &[(&str, Option<bool>)]) -> AppsRequirementsToml {AppsRequirementsToml {apps: entries@@ -3135,6 +3233,7 @@ allowed_approvals_reviewers = ["user"]tool_name.to_string(),AppToolRequirementToml {approval_mode: Some(approval_mode),+ analytics_result_source: None,},)]),}),diff --git a/codex-rs/config/src/lib.rs b/codex-rs/config/src/lib.rsindex fc5e05a687..0b41b2e04e 100644--- a/codex-rs/config/src/lib.rs+++ b/codex-rs/config/src/lib.rs@@ -83,6 +83,8 @@ pub use config_layer_source::ConfigLayerSource;pub use config_layer_source::format_config_layer_source;pub use config_requirements::AppRequirementToml;pub use config_requirements::AppToolRequirementToml;+pub use config_requirements::AppToolResultSourceFormat;+pub use config_requirements::AppToolResultSourceRequirementToml;pub use config_requirements::AppToolsRequirementsToml;pub use config_requirements::AppsRequirementsToml;pub use config_requirements::AutoReviewRequirementsToml;diff --git a/codex-rs/connectors/src/app_tool_policy_tests.rs b/codex-rs/connectors/src/app_tool_policy_tests.rsindex 8d2222fdaa..e255de4972 100644--- a/codex-rs/connectors/src/app_tool_policy_tests.rs+++ b/codex-rs/connectors/src/app_tool_policy_tests.rs@@ -53,6 +53,7 @@ fn evaluator_reuses_one_snapshot_across_tools() {"events/create".to_string(),AppToolRequirementToml {approval_mode: Some(AppToolApproval::Approve),+ ..Default::default()},)]),}),@@ -937,6 +938,7 @@ fn app_tool_requirements(tool_name.to_string(),AppToolRequirementToml {approval_mode: Some(approval_mode),+ ..Default::default()},)]),}),diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rsindex cda42c5a13..ec4843b5aa 100644--- a/codex-rs/core/src/tools/executed_tool_calls.rs+++ b/codex-rs/core/src/tools/executed_tool_calls.rs@@ -8,6 +8,7 @@ use codex_protocol::models::ResponseItem;use codex_protocol::models::bound_executed_tool_calls_for_prompt_prioritizing_recent;use codex_protocol::models::executed_tool_call_metadata_bytes;use codex_protocol::openai_models::ToolMode;+use indexmap::IndexMap;use serde_json::Value as JsonValue;use crate::tools::context::ToolCallSource;@@ -42,6 +43,9 @@ struct RetainedToolCalls {complete: bool,cell_id: Option<String>,runtime_cell_id: Option<CellId>,+ // Invocation IDs stay local and are retained only with their original output's calls.+ call_index_by_id: HashMap<String, usize>,+ sources_updated: bool,}#[derive(Default, PartialEq, Eq)]@@ -56,7 +60,7 @@ enum CellCompletion {#[derive(Default)]struct RecordedCell {- pending_calls: Vec<ExecutedToolCall>,+ pending_calls: IndexMap<String, ExecutedToolCall>,pending_full_argument_bytes: usize,completion: CellCompletion,originating_call_id: Option<String>,@@ -169,6 +173,7 @@ impl ExecutedToolCallRecorder {ToolCallSource::CodeMode { cell_id, .. } => {self.record_nested_tool_call(CellId::new(cell_id.clone()),+ call.call_id.clone(),recorded_call,original_bytes,);@@ -179,6 +184,7 @@ impl ExecutedToolCallRecorder {fn record_nested_tool_call(&self,cell_id: CellId,+ call_id: String,call: ExecutedToolCall,original_bytes: usize,) {@@ -222,10 +228,49 @@ impl ExecutedToolCallRecorder {} else {CellCompletion::Incomplete};- cell.pending_calls.push(call);+ cell.pending_calls.insert(call_id, call);state.pending_nested_calls += 1;}+ pub(crate) fn record_tool_result_sources(+ &self,+ source: &ToolCallSource,+ call_id: &str,+ result_sources: codex_protocol::models::ToolResultSources,+ ) -> bool {+ let mut state = self+ .state+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ let call = match source {+ ToolCallSource::Direct | ToolCallSource::DirectPlaintextMessage => {+ state.direct_calls.get_mut(call_id)+ }+ ToolCallSource::CodeMode { cell_id, .. } => state+ .cells+ .get_mut(&CellId::new(cell_id.clone()))+ .and_then(|cell| cell.pending_calls.get_mut(call_id)),+ };+ if let Some(call) = call {+ return call.set_tool_result_sources(result_sources);+ }+ let ToolCallSource::CodeMode { cell_id, .. } = source else {+ return false;+ };+ let Some((retained, index)) = state.retained_calls.values_mut().find_map(|retained| {+ if retained.runtime_cell_id.as_ref()?.as_str() != cell_id.as_str() {+ return None;+ }+ let index = *retained.call_index_by_id.get(call_id)?;+ Some((retained, index))+ }) else {+ return false;+ };+ // Older retry copies must not overwrite this output's accepted result metadata.+ retained.sources_updated = true;+ retained.calls[index].set_tool_result_sources(result_sources)+ }+pub(crate) fn attach_pending_to_prompt(&self,items: &mut [ResponseItem],@@ -246,6 +291,13 @@ impl ExecutedToolCallRecorder {return false;}+ // Updated records supersede older retry snapshots.+ retry_cache.retain(|key, _| {+ !state+ .retained_calls+ .get(key)+ .is_some_and(|retained| retained.sources_updated)+ });let mut pending_retry_outputs = retry_cache.keys().cloned().collect::<HashSet<_>>();let mut pending_retained_outputs =state.retained_calls.keys().cloned().collect::<HashSet<_>>();@@ -294,13 +346,19 @@ impl ExecutedToolCallRecorder {.remove(call_id).into_iter().collect::<Vec<_>>();+ let mut call_index_by_id = HashMap::new();if let Some(output_cell_id) = state.output_cells.remove(call_id)&& let Some(cell) = state.cells.get_mut(&output_cell_id){cell_id = cell.originating_call_id.clone();runtime_cell_id = Some(output_cell_id.clone());let pending_calls = cell.pending_calls.len();- calls.append(&mut cell.pending_calls);+ for (call_id, call) in cell.pending_calls.drain(..) {+ if matches!(call.arguments(), ExecutedToolCallArguments::Raw(_)) {+ call_index_by_id.insert(call_id, calls.len());+ }+ calls.push(call);+ }cell.pending_full_argument_bytes = 0;complete = cell.completion == CellCompletion::Complete;if matches!(@@ -326,6 +384,8 @@ impl ExecutedToolCallRecorder {complete,cell_id: cell_id.clone(),runtime_cell_id,+ call_index_by_id,+ sources_updated: false,},);calls@@ -348,6 +408,7 @@ impl ExecutedToolCallRecorder {if retained_bytes > MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT {bound_executed_tool_calls_for_prompt_prioritizing_recent(items);let retained_before_bounding = std::mem::take(&mut state.retained_calls);+ let mut bounded_outputs = HashSet::new();for item in items {let call_id = match &*item {ResponseItem::FunctionCallOutput {@@ -363,10 +424,15 @@ impl ExecutedToolCallRecorder {};let key = (std::mem::discriminant(&*item), call_id.clone());let metadata = item.executed_tool_call_metadata();- if let Some(retained) = retained_before_bounding.get(&key)+ let unique_output = bounded_outputs.insert(key.clone());+ if !unique_output && let Some(retained) = state.retained_calls.get_mut(&key) {+ retained.call_index_by_id.clear();+ }+ let previous = retained_before_bounding.get(&key);+ if let Some(retained) = previous&& let Some(runtime_cell_id) = &retained.runtime_cell_id- && metadata.and_then(|metadata| metadata.executed_tool_calls.as_ref())- != Some(&retained.calls)+ && metadata+ .is_none_or(|metadata| !metadata.has_same_tool_calls(&retained.calls))&& let Some(cell) = state.cells.get_mut(runtime_cell_id){cell.completion = CellCompletion::Incomplete;@@ -378,9 +444,16 @@ impl ExecutedToolCallRecorder {.is_some_and(|calls| !calls.is_empty())|| metadata.tool_calls_complete.is_some()){- let runtime_cell_id = retained_before_bounding- .get(&key)- .and_then(|retained| retained.runtime_cell_id.clone());+ let runtime_cell_id =+ previous.and_then(|retained| retained.runtime_cell_id.clone());+ // Budget rewriting or duplicate outputs invalidate the original index slots.+ let call_index_by_id = previous+ .filter(|retained| {+ unique_output+ && metadata.executed_tool_calls.as_ref() == Some(&retained.calls)+ })+ .map(|retained| retained.call_index_by_id.clone())+ .unwrap_or_default();let retained = state.retained_calls.entry(key).or_default();retained.runtime_cell_id = runtime_cell_id;retained.calls = metadata.executed_tool_calls.clone().unwrap_or_default();@@ -388,6 +461,9 @@ impl ExecutedToolCallRecorder {retained.cell_id = Some(cell_id.clone());}retained.complete |= metadata.tool_calls_complete == Some(true);+ retained.call_index_by_id = call_index_by_id;+ retained.sources_updated =+ previous.is_some_and(|retained| retained.sources_updated);}}}diff --git a/codex-rs/core/src/tools/executed_tool_calls_tests.rs b/codex-rs/core/src/tools/executed_tool_calls_tests.rsindex 3a2011aaad..441ac44dfb 100644--- a/codex-rs/core/src/tools/executed_tool_calls_tests.rs+++ b/codex-rs/core/src/tools/executed_tool_calls_tests.rs@@ -1,5 +1,6 @@use codex_protocol::models::FunctionCallOutputPayload;use codex_protocol::models::ResponseInputItem;+use codex_protocol::models::ToolResultSources;use pretty_assertions::assert_eq;use serde_json::json;@@ -30,12 +31,18 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {ToolMode::Direct,);}+ assert!(recorder.record_tool_result_sources(+ &ToolCallSource::Direct,+ "direct-0",+ ToolResultSources::new(Vec::new())+ ));let cell_id = CellId::new("bounded-cell".to_string());recorder.start_cell(&cell_id, "bounded-output");- for _ in 0..MAX_PENDING_EXECUTED_TOOL_CALLS + 2 {+ for index in 0..MAX_PENDING_EXECUTED_TOOL_CALLS + 2 {recorder.record_nested_tool_call(cell_id.clone(),+ format!("nested-{index}"),ExecutedToolCall::new("nested_tool".to_string(), json!({})),/*original_bytes*/ 2,);@@ -251,6 +258,7 @@ fn tool_call_completeness_requires_finished_lossless_recording() {if scenario != "empty" {recorder.record_nested_tool_call(cell_id.clone(),+ "nested-call".to_string(),ExecutedToolCall::new("nested_tool".to_string(), json!({})),/*original_bytes*/ 2,);@@ -271,12 +279,22 @@ fn tool_call_completeness_requires_finished_lossless_recording() {#[test]fn tool_call_completeness_survives_waits_without_changing_deltas() {- for truncated in [false, true] {+ let sources = ToolResultSources::new(vec![codex_protocol::models::ToolResultSource {+ r#type: "test_channel".to_string(),+ id: "CLATE".to_string(),+ }]);+ for (truncated, sources) in [+ (false, sources.clone()),+ (true, sources),+ (false, ToolResultSources::parse_failed()),+ (true, ToolResultSources::parse_failed()),+ ] {let recorder = ExecutedToolCallRecorder::default();let cell_id = CellId::new("multi-wait".to_string());recorder.start_cell(&cell_id, "exec");let mut history = Vec::new();let mut expected = Vec::new();+ let mut retry_cache = HashMap::new();for (index, call_id) in ["exec", "wait-1", "wait-2", "wait-3"].into_iter().enumerate()@@ -296,7 +314,43 @@ fn tool_call_completeness_survives_waits_without_changing_deltas() {} else {ExecutedToolCall::new("nested_tool".to_string(), json!({}))};- recorder.record_nested_tool_call(cell_id.clone(), call.clone(), original_bytes);+ recorder.record_nested_tool_call(+ cell_id.clone(),+ format!("nested-{index}"),+ call.clone(),+ original_bytes,+ );+ let mut call = call;+ if index == 1 {+ let source = |cell_id: &str| ToolCallSource::CodeMode {+ cell_id: cell_id.to_string(),+ runtime_tool_call_id: "runtime-call".to_string(),+ };+ assert!(!recorder.record_tool_result_sources(+ &source("other-cell"),+ "nested-0",+ ToolResultSources::new(Vec::new()),+ ));+ let source = source(cell_id.as_str());+ assert!(recorder.record_tool_result_sources(+ &source,+ "nested-0",+ sources.clone(),+ ));+ let mut delayed_call =+ ExecutedToolCall::new("nested_tool".to_string(), json!({}));+ assert!(delayed_call.set_tool_result_sources(sources.clone()));+ let mut delayed_output = output("exec");+ delayed_output.append_executed_tool_calls(vec![delayed_call]);+ delayed_output.set_tool_call_cell_id("exec");+ expected[0] = delayed_output;+ assert!(recorder.record_tool_result_sources(+ &source,+ "nested-1",+ ToolResultSources::new(Vec::new())+ ));+ assert!(call.set_tool_result_sources(ToolResultSources::new(Vec::new())));+ }expected_output.append_executed_tool_calls(vec![call]);} else if index == 3 {recorder.finish_cell_recording(&cell_id);@@ -308,7 +362,6 @@ fn tool_call_completeness_survives_waits_without_changing_deltas() {expected_output.mark_tool_calls_complete();}expected.push(expected_output);- let mut retry_cache = HashMap::new();for _ in 0..2 {let mut prompt = history.clone();assert!(recorder.attach_pending_to_prompt(&mut prompt, &mut retry_cache));@@ -330,6 +383,7 @@ fn cell_correlation_uses_originating_exec_across_runtime_restarts() {recorder.start_cell(&runtime_cell_id, originating_call_id);recorder.record_nested_tool_call(runtime_cell_id.clone(),+ "nested-call".to_string(),ExecutedToolCall::new("nested_tool".to_string(), json!({})),/*original_bytes*/ 2,);@@ -364,9 +418,10 @@ fn request_truncation_prevents_completion_after_compaction() {let arguments = json!({"payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - r#"{"payload":""}"#.len()),});- for _ in 0..4 {+ for index in 0..4 {recorder.record_nested_tool_call(cell_id.clone(),+ format!("nested-{index}"),ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,);@@ -383,6 +438,17 @@ fn request_truncation_prevents_completion_after_compaction() {ExecutedToolCallArguments::Truncated { .. }))));+ let source = ToolCallSource::CodeMode {+ cell_id: cell_id.as_str().to_string(),+ runtime_tool_call_id: "runtime-call".to_string(),+ };+ for index in 0..4 {+ assert!(!recorder.record_tool_result_sources(+ &source,+ &format!("nested-{index}"),+ ToolResultSources::new(Vec::new()),+ ));+ }recorder.attach_pending_to_prompt(&mut [], &mut HashMap::new());recorder.register_cell(&cell_id, "wait");@@ -397,6 +463,88 @@ fn request_truncation_prevents_completion_after_compaction() {);}+#[test]+fn source_shedding_preserves_completion_after_compaction() {+ let recorder = ExecutedToolCallRecorder::default();+ let cell_id = CellId::new("compacted-cell".to_string());+ recorder.start_cell(&cell_id, "exec");++ let argument_bytes = MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - 256;+ let arguments = json!({+ "payload": "x".repeat(argument_bytes - r#"{"payload":""}"#.len()),+ });+ for index in 0..4 {+ recorder.record_nested_tool_call(+ cell_id.clone(),+ format!("nested-{index}"),+ ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),+ argument_bytes,+ );+ }+ let source = ToolCallSource::CodeMode {+ cell_id: cell_id.as_str().to_string(),+ runtime_tool_call_id: "runtime-call".to_string(),+ };+ let mut retry_cache = HashMap::new();+ recorder.attach_pending_to_prompt(&mut [output("exec")], &mut retry_cache);+ assert!(+ recorder.record_tool_result_sources(+ &source,+ "nested-0",+ ToolResultSources::new(+ (0..32)+ .map(|index| codex_protocol::models::ToolResultSource {+ r#type: "test_channel".to_string(),+ id: format!("C{index:063}"),+ })+ .collect()+ ),+ )+ );++ assert!(recorder.record_tool_result_sources(+ &source,+ "nested-1",+ ToolResultSources::parse_failed()+ ));+ let mut initial = [output("exec")];+ assert!(recorder.attach_pending_to_prompt(&mut initial, &mut retry_cache));+ let calls = initial[0]+ .executed_tool_call_metadata()+ .and_then(|metadata| metadata.executed_tool_calls.as_ref())+ .expect("source shedding must preserve recorded calls");+ assert_eq!(+ calls,+ &vec![ExecutedToolCall::new("nested_tool".to_string(), arguments); 4]+ );+ assert!(!recorder.record_tool_result_sources(+ &source,+ "nested-0",+ ToolResultSources::new(Vec::new())+ ));+ let mut retry = [output("exec")];+ assert!(recorder.attach_pending_to_prompt(&mut retry, &mut retry_cache));+ assert_eq!(retry, initial);++ recorder.attach_pending_to_prompt(&mut [], &mut retry_cache);+ assert!(retry_cache.is_empty());+ assert!(!recorder.record_tool_result_sources(+ &source,+ "nested-1",+ ToolResultSources::new(Vec::new())+ ));+ recorder.register_cell(&cell_id, "wait");+ recorder.finish_cell_recording(&cell_id);+ let mut final_output = [output("wait")];+ recorder.attach_pending_to_prompt(&mut final_output, &mut HashMap::new());+ assert_eq!(+ final_output[0]+ .executed_tool_call_metadata()+ .and_then(|metadata| metadata.tool_calls_complete),+ Some(true),+ );+}+#[test]fn finished_cells_without_more_waits_do_not_block_new_calls() {let recorder = ExecutedToolCallRecorder::default();@@ -404,13 +552,23 @@ fn finished_cells_without_more_waits_do_not_block_new_calls() {for index in 0..MAX_PENDING_EXECUTED_TOOL_CALLS {let cell = CellId::new(format!("cell-{index}"));recorder.start_cell(&cell, cell.as_str());- recorder.record_nested_tool_call(cell.clone(), call.clone(), /*original_bytes*/ 2);+ recorder.record_nested_tool_call(+ cell.clone(),+ format!("nested-{index}"),+ call.clone(),+ /*original_bytes*/ 2,+ );recorder.attach_pending_to_prompt(&mut [output(cell.as_str())], &mut HashMap::new());recorder.finish_cell_recording(&cell);}let fresh = CellId::new("fresh".to_string());recorder.start_cell(&fresh, "fresh-output");- recorder.record_nested_tool_call(fresh.clone(), call.clone(), /*original_bytes*/ 2);+ recorder.record_nested_tool_call(+ fresh.clone(),+ "fresh-call".to_string(),+ call.clone(),+ /*original_bytes*/ 2,+ );recorder.finish_cell_recording(&fresh);let mut expected = output("fresh-output");expected.append_executed_tool_calls(vec![call]);diff --git a/codex-rs/core/src/tools/handlers/mcp.rs b/codex-rs/core/src/tools/handlers/mcp.rsindex 4d45c64349..48e828fcfa 100644--- a/codex-rs/core/src/tools/handlers/mcp.rs+++ b/codex-rs/core/src/tools/handlers/mcp.rs@@ -284,6 +284,12 @@ impl CoreToolRuntime for McpHandler {}fn on_tool_result_accepted(&self, invocation: &ToolInvocation, result: &dyn ToolOutput) {+ // Direct calls also record sources, before the Code Mode-only evidence path below.+ if let Some(recorder) = invocation.session.services.executed_tool_calls.as_ref()+ && let Some(sources) = result.tool_result_sources()+ {+ recorder.record_tool_result_sources(&invocation.source, &invocation.call_id, sources);+ }let ToolCallSource::CodeMode { cell_id, .. } = &invocation.source else {return;};diff --git a/codex-rs/core/src/tools/registry.rs b/codex-rs/core/src/tools/registry.rsindex 8e19ece6bc..e73711f8e6 100644--- a/codex-rs/core/src/tools/registry.rs+++ b/codex-rs/core/src/tools/registry.rs@@ -242,6 +242,10 @@ impl ToolOutput for PostToolUseFeedbackOutput {fn code_mode_result(&self, payload: &ToolPayload) -> Value {self.original.code_mode_result(payload)}++ fn tool_result_sources(&self) -> Option<codex_protocol::models::ToolResultSources> {+ self.original.tool_result_sources()+ }}#[derive(Debug, Clone, PartialEq, Eq)]diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rsindex 9005f811a0..71846545fe 100644--- a/codex-rs/protocol/src/models.rs+++ b/codex-rs/protocol/src/models.rs@@ -41,6 +41,9 @@ pub use crate::permission_profile_snapshot::PermissionProfileSnapshot;pub use executed_tool_calls::ExecutedToolCall;pub use executed_tool_calls::ExecutedToolCallArguments;pub use executed_tool_calls::ExecutedToolCallTruncation;+pub use executed_tool_calls::MAX_TOOL_RESULT_SOURCE_FIELD_BYTES;+pub use executed_tool_calls::ToolResultSource;+pub use executed_tool_calls::ToolResultSources;pub use executed_tool_calls::bound_executed_tool_calls_for_prompt;pub use executed_tool_calls::bound_executed_tool_calls_for_prompt_prioritizing_recent;pub use executed_tool_calls::executed_tool_call_metadata_bytes;diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rsindex 8f504ff05c..b07ffba3b5 100644--- a/codex-rs/protocol/src/models/executed_tool_calls.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs@@ -7,6 +7,10 @@ use super::InternalChatMessageMetadataPassthrough;use super::ResponseItem;const MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES: usize = 8 * 1024;+/// Maximum distinct result sources retained for one tool invocation.+const MAX_TOOL_RESULT_SOURCES: usize = 32;+/// Maximum UTF-8 bytes for each source's `type` and `id` separately, not the source list.+pub const MAX_TOOL_RESULT_SOURCE_FIELD_BYTES: usize = 128;/// Maximum serialized warehouse-only attempted-tool metadata in one request.const MAX_EXECUTED_TOOL_CALL_METADATA_BYTES: usize = 32 * 1024;const EXECUTED_TOOL_CALL_METADATA_FIELD_BYTES: usize = b"\"executed_tool_calls\":".len();@@ -56,6 +60,18 @@ pub fn executed_tool_call_metadata_bytes(item: &ResponseItem) -> usize {.saturating_add(executed_tool_call_metadata_field_bytes(metadata))}+impl InternalChatMessageMetadataPassthrough {+ /// Compares call order, names and arguments, ignoring optional source metadata.+ pub fn has_same_tool_calls(&self, calls: &[ExecutedToolCall]) -> bool {+ self.executed_tool_calls.as_ref().is_some_and(|recorded| {+ recorded.len() == calls.len()+ && recorded.iter().zip(calls).all(|(recorded, call)| {+ recorded.name == call.name && recorded.arguments() == call.arguments()+ })+ })+ }+}+/// Bounds attempted-tool metadata fairly across the complete serialized request.pub fn bound_executed_tool_calls_for_prompt(items: &mut [ResponseItem]) {bound_executed_tool_calls_for_prompt_with_priority(items, /*prioritize_recent*/ false);@@ -112,6 +128,23 @@ fn bound_executed_tool_calls_for_prompt_with_priority(original_metadata_bytes.saturating_add(executed_tool_call_metadata_bytes(item));}+ // Source evidence is optional; dropping it must not discard calls or their completion proof.+ if original_metadata_bytes > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {+ original_metadata_bytes = 0;+ for item in items.iter_mut() {+ if let Some(metadata) = item+ .internal_chat_message_metadata_passthrough_mut()+ .and_then(Option::as_mut)+ {+ for call in metadata.executed_tool_calls.iter_mut().flatten() {+ call.tool_result_sources = None;+ }+ }+ original_metadata_bytes =+ original_metadata_bytes.saturating_add(executed_tool_call_metadata_bytes(item));+ }+ }+// A terminal marker can be on an empty wait output, separate from the lost calls.if truncated || original_metadata_bytes > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {for item in items.iter_mut() {@@ -298,6 +331,58 @@ pub struct ExecutedToolCall {pub name: String,#[ts(type = "unknown")]arguments: ExecutedToolCallArguments,+ /// Host-generated analytics only: ignore input JSON rather than accepting caller-supplied+ /// evidence, and keep this out of public schemas and generated clients.+ #[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]+ #[schemars(skip)]+ #[ts(skip)]+ tool_result_sources: Option<ToolResultSourcesValue>,+}++/// A bounded capture update. Omitted updates still clear any previously recorded evidence.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct ToolResultSources(Option<ToolResultSourcesValue>);++#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+enum ToolResultSourcesValue {+ #[serde(rename = "parse_failed")]+ ParseFailed,+ // Preserve the existing array shape for successful captures, including an empty array.+ #[serde(untagged)]+ Sources(Vec<ToolResultSource>),+}++impl ToolResultSources {+ /// Deduplicates a complete source list, discarding all sources if it exceeds a limit.+ pub fn new(sources: Vec<ToolResultSource>) -> Self {+ let mut unique_sources = Vec::new();+ for source in sources {+ if unique_sources.contains(&source) {+ continue;+ }+ if unique_sources.len() == MAX_TOOL_RESULT_SOURCES+ || source.r#type.len() > MAX_TOOL_RESULT_SOURCE_FIELD_BYTES+ || source.id.len() > MAX_TOOL_RESULT_SOURCE_FIELD_BYTES+ {+ return Self(None);+ }+ unique_sources.push(source);+ }+ Self(Some(ToolResultSourcesValue::Sources(unique_sources)))+ }++ /// Records that source parsing was attempted but failed, not that a budget was exceeded.+ pub fn parse_failed() -> Self {+ Self(Some(ToolResultSourcesValue::ParseFailed))+ }+}++/// A trusted source identity observed in an accepted tool result by the host.+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct ToolResultSource {+ #[serde(rename = "type")]+ pub r#type: String,+ pub id: String,}/// Trusted truncation details generated locally for an oversized attempted tool call.@@ -325,6 +410,7 @@ impl ExecutedToolCall {Self {name,arguments: ExecutedToolCallArguments::Raw(arguments),+ tool_result_sources: None,}}@@ -340,6 +426,12 @@ impl ExecutedToolCall {&self.arguments}+ /// Replaces this invocation's capture outcome, including clearing omitted evidence.+ pub fn set_tool_result_sources(&mut self, sources: ToolResultSources) -> bool {+ self.tool_result_sources = sources.0;+ self.tool_result_sources.is_some()+ }+fn truncation(&self) -> Option<&ExecutedToolCallTruncation> {match &self.arguments {ExecutedToolCallArguments::Raw(_) => None,diff --git a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs b/codex-rs/protocol/src/models/executed_tool_calls_tests.rsindex b49443fd11..34f673a8ea 100644--- a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs+++ b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs@@ -140,6 +140,42 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {assert_eq!(oversized_items, bounded_items);}+ let mut items = ["exec", "wait"].map(|call_id| {+ let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {+ call_id: call_id.to_string(),+ output: FunctionCallOutputPayload::from_text(String::new()),+ });+ item.set_tool_call_cell_id("cell-\"\\");+ item+ });+ items[0].append_executed_tool_calls(vec![+ ExecutedToolCall::new(+ "test_tool".to_string(),+ serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - 256) }),+ );+ 4+ ]);+ items[1].mark_tool_calls_complete();+ let expected = items.clone();+ assert!(+ first_executed_tool_call(&mut items[0])+ .expect("recorded call should exist")+ .set_tool_result_sources(ToolResultSources::new(+ (0..MAX_TOOL_RESULT_SOURCES)+ .map(|index| ToolResultSource {+ r#type: "document".to_string(),+ id: format!(+ "R{index:0width$}",+ width = MAX_TOOL_RESULT_SOURCE_FIELD_BYTES - 1+ ),+ })+ .collect(),+ ))+ );+ assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);+ bound_executed_tool_calls_for_prompt(&mut items);+ assert_eq!(items, expected);+// Empty waits can carry only the marker; its bytes still count toward the budget.for metadata in [None, Some(passthrough_metadata("turn-1"))] {let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {@@ -229,6 +265,17 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {"tool_calls_complete": true,}))?;assert_eq!(untrusted, passthrough_metadata("turn-1"));+ for sources in [+ serde_json::json!([{ "type": "test_resource", "id": "ATTACKER" }]),+ serde_json::json!("parse_failed"),+ ] {+ let untrusted_call = serde_json::from_value::<ExecutedToolCall>(serde_json::json!({+ "name": "test_tool",+ "arguments": {},+ "tool_result_sources": sources,+ }))?;+ assert_eq!(untrusted_call, call);+ }let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {call_id: "call-1".to_string(),@@ -272,3 +319,72 @@ fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {}Ok(())}++#[test]+fn tool_result_source_snapshots_replace_atomically() -> Result<()> {+ let source = |kind: &str, id: &str| ToolResultSource {+ r#type: kind.to_string(),+ id: id.to_string(),+ };+ let mut call = ExecutedToolCall::new("test_tool".to_string(), serde_json::json!({}));+ let mut sources = (0..MAX_TOOL_RESULT_SOURCES - 1)+ .map(|index| source("test_resource", &format!("R{index}")))+ .collect::<Vec<_>>();+ sources.push(source("other_resource", "R0"));+ sources.push(sources[0].clone());+ let capture = ToolResultSources::new(sources.clone());+ sources.truncate(MAX_TOOL_RESULT_SOURCES);+ assert_eq!(+ capture,+ ToolResultSources(Some(ToolResultSourcesValue::Sources(sources.clone())))+ );+ assert!(call.set_tool_result_sources(capture));+ sources.push(source("test_resource", "OVERFLOW"));+ let capture = ToolResultSources::new(sources);+ assert_eq!(capture, ToolResultSources(None));+ assert!(!call.set_tool_result_sources(capture));+ assert!(+ serde_json::to_value(&call)?+ .get("tool_result_sources")+ .is_none()+ );++ // Measure UTF-8 bytes, and clear old evidence instead of keeping a partial replacement.+ let field = format!(+ "é{}",+ "x".repeat(MAX_TOOL_RESULT_SOURCE_FIELD_BYTES - "é".len())+ );+ let bounded = source(&field, &field);+ let oversized = format!("{field}x");+ for invalid in [+ source(&oversized, "R1"),+ source("test_resource", &oversized),+ ] {+ assert!(call.set_tool_result_sources(ToolResultSources::new(vec![bounded.clone()])));+ assert_eq!(+ call.tool_result_sources,+ Some(ToolResultSourcesValue::Sources(vec![bounded.clone()]))+ );+ let capture = ToolResultSources::new(vec![source("test_resource", "R1"), invalid]);+ assert_eq!(capture, ToolResultSources(None));+ assert!(!call.set_tool_result_sources(capture));+ assert_eq!(call.tool_result_sources, None);+ }++ assert!(call.set_tool_result_sources(ToolResultSources::new(vec![bounded])));+ assert!(call.set_tool_result_sources(ToolResultSources::parse_failed()));+ assert_eq!(+ serde_json::to_value(&call)?,+ serde_json::json!({+ "name": "test_tool",+ "arguments": {},+ "tool_result_sources": "parse_failed",+ })+ );+ assert!(call.set_tool_result_sources(ToolResultSources::new(Vec::new())));+ assert_eq!(+ serde_json::to_value(&call)?["tool_result_sources"],+ serde_json::json!([])+ );+ Ok(())+}diff --git a/codex-rs/tools/src/tool_output.rs b/codex-rs/tools/src/tool_output.rsindex 0aa22b626d..a33232e20d 100644--- a/codex-rs/tools/src/tool_output.rs+++ b/codex-rs/tools/src/tool_output.rs@@ -55,6 +55,11 @@ pub trait ToolOutput: Send {fn code_mode_result(&self, payload: &ToolPayload) -> JsonValue {response_input_to_code_mode_result(self.to_response_item("", payload))}++ /// Reports configured source capture only after acceptance; `None` means no capture attempt.+ fn tool_result_sources(&self) -> Option<codex_protocol::models::ToolResultSources> {+ None+ }}impl<T> ToolOutput for Box<T>@@ -96,6 +101,10 @@ wherefn code_mode_result(&self, payload: &ToolPayload) -> JsonValue {(**self).code_mode_result(payload)}++ fn tool_result_sources(&self) -> Option<codex_protocol::models::ToolResultSources> {+ (**self).tool_result_sources()+ }}#[derive(Clone, Debug, PartialEq)]