Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Track Code Mode tool call metadata completeness (#41058)

ningyi-oaid5caceccb1ee
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs
index e0250aee6d..c5082fda91 100644
--- a/codex-rs/core/src/session/session.rs
+++ b/codex-rs/core/src/session/session.rs
@@ -1428,10 +1428,11 @@ impl Session {
session_configuration.parent_thread_id,
),
),
- executed_tool_calls,
+ executed_tool_calls: executed_tool_calls.clone(),
code_mode_service: crate::tools::code_mode::CodeModeService::new(
Arc::clone(&code_mode_session_provider),
&config.code_mode,
+ executed_tool_calls,
),
tool_search_handler_cache: Default::default(),
turn_environments: Arc::clone(&turn_environments),
diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs
index 9aa49c1a19..e9b3227aee 100644
--- a/codex-rs/core/src/session/tests.rs
+++ b/codex-rs/core/src/session/tests.rs
@@ -6336,10 +6336,11 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
/*attestation_provider*/ None,
config.http_client_factory(),
),
- executed_tool_calls,
+ executed_tool_calls: executed_tool_calls.clone(),
code_mode_service: crate::tools::code_mode::CodeModeService::new(
Arc::new(codex_code_mode::DisabledCodeModeSessionProvider),
&config.code_mode,
+ executed_tool_calls,
),
tool_search_handler_cache: Default::default(),
turn_environments: Arc::clone(&turn_environments),
@@ -8614,10 +8615,11 @@ where
/*attestation_provider*/ None,
config.http_client_factory(),
),
- executed_tool_calls,
+ executed_tool_calls: executed_tool_calls.clone(),
code_mode_service: crate::tools::code_mode::CodeModeService::new(
Arc::new(codex_code_mode::DisabledCodeModeSessionProvider),
&config.code_mode,
+ executed_tool_calls,
),
tool_search_handler_cache: Default::default(),
turn_environments: Arc::clone(&turn_environments),
diff --git a/codex-rs/core/src/tools/code_mode/delegate.rs b/codex-rs/core/src/tools/code_mode/delegate.rs
index 56389b0f3b..0319d13d36 100644
--- a/codex-rs/core/src/tools/code_mode/delegate.rs
+++ b/codex-rs/core/src/tools/code_mode/delegate.rs
@@ -18,8 +18,9 @@ use tracing::Instrument;
use super::ExecContext;
use super::PUBLIC_TOOL_NAME;
-use super::call_nested_tool;
+use super::submit_nested_tool;
use crate::session::step_context::StepContext;
+use crate::tools::ExecutedToolCallRecorder;
use crate::tools::context::SharedTurnDiffTracker;
use crate::tools::parallel::ToolCallRuntime;
@@ -27,6 +28,7 @@ pub(super) struct CodeModeDispatchBroker {
dispatch_tx: async_channel::Sender<DispatchMessage>,
dispatch_rx: async_channel::Receiver<DispatchMessage>,
dispatch_gates: Arc<Mutex<HashMap<CellId, CellDispatchGate>>>,
+ executed_tool_calls: Option<Arc<ExecutedToolCallRecorder>>,
}
struct CellDispatchGate {
@@ -36,12 +38,13 @@ struct CellDispatchGate {
}
impl CodeModeDispatchBroker {
- pub(super) fn new() -> Self {
+ pub(super) fn new(executed_tool_calls: Option<Arc<ExecutedToolCallRecorder>>) -> Self {
let (dispatch_tx, dispatch_rx) = async_channel::unbounded();
Self {
dispatch_tx,
dispatch_rx,
dispatch_gates: Arc::new(Mutex::new(HashMap::new())),
+ executed_tool_calls,
}
}
@@ -76,7 +79,14 @@ impl CodeModeDispatchBroker {
}
pub(super) fn close_cell(&self, cell_id: &CellId) {
- remove_dispatch_gate(&self.dispatch_gates, cell_id);
+ let mut dispatch_gates = self
+ .dispatch_gates
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ dispatch_gates.remove(cell_id);
+ if let Some(recorder) = &self.executed_tool_calls {
+ recorder.finish_cell_recording(cell_id);
+ }
}
pub(super) fn active_cell_ids(&self) -> Vec<CellId> {
@@ -94,6 +104,11 @@ impl CodeModeDispatchBroker {
step_context: Arc<StepContext>,
tracker: SharedTurnDiffTracker,
) -> CodeModeDispatchWorker {
+ let track_completeness = exec
+ .turn
+ .config
+ .features
+ .enabled(codex_features::Feature::ExecutedToolCallMetadata);
let tool_runtime = ToolCallRuntime::new(Arc::clone(&exec.session), step_context, tracker);
let host = Arc::new(CoreTurnHost { exec, tool_runtime });
let dispatch_rx = self.dispatch_rx.clone();
@@ -148,10 +163,26 @@ impl CodeModeDispatchBroker {
continue;
}
let host = Arc::clone(&host);
+ let dispatch_gates = Arc::clone(&dispatch_gates);
tokio::spawn(async move {
- let invocation = host
- .invoke_tool(invocation, cancellation_token.clone())
- .instrument(span);
+ let invocation = {
+ let dispatch_gate = track_completeness.then(|| {
+ dispatch_gates
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ });
+ if dispatch_gate.as_ref().is_some_and(|gates| {
+ cancellation_token.is_cancelled()
+ || !gates.contains_key(&cell_id)
+ }) {
+ return;
+ }
+ // Submission and cell closure share this gate.
+ span.in_scope(|| {
+ host.submit_tool(invocation, cancellation_token.clone())
+ })
+ .instrument(span)
+ };
tokio::pin!(invocation);
let response = tokio::select! {
biased;
@@ -324,19 +355,19 @@ struct CoreTurnHost {
}
impl CoreTurnHost {
- async fn invoke_tool(
+ fn submit_tool(
&self,
invocation: CodeModeNestedToolCall,
cancellation_token: CancellationToken,
- ) -> Result<JsonValue, String> {
- call_nested_tool(
+ ) -> impl std::future::Future<Output = Result<JsonValue, String>> + Send + 'static {
+ let invocation = submit_nested_tool(
self.exec.clone(),
self.tool_runtime.clone(),
invocation,
cancellation_token,
)
- .await
- .map_err(|error| error.to_string())
+ .map_err(|error| error.to_string());
+ async move { invocation?.await.map_err(|error| error.to_string()) }
}
async fn notify(&self, call_id: String, cell_id: CellId, text: String) -> Result<(), String> {
diff --git a/codex-rs/core/src/tools/code_mode/execute_handler.rs b/codex-rs/core/src/tools/code_mode/execute_handler.rs
index c8a497fac1..313290da5a 100644
--- a/codex-rs/core/src/tools/code_mode/execute_handler.rs
+++ b/codex-rs/core/src/tools/code_mode/execute_handler.rs
@@ -88,7 +88,7 @@ impl CodeModeExecuteHandler {
cell_id: cell_id.to_string(),
});
if let Some(executed_tool_calls) = exec.session.services.executed_tool_calls.as_ref() {
- executed_tool_calls.register_cell(&cell_id, &call_id);
+ executed_tool_calls.start_cell(&cell_id, &call_id);
}
let runtime_cell_id = cell_id.to_string();
let code_cell_trace = exec
diff --git a/codex-rs/core/src/tools/code_mode/mod.rs b/codex-rs/core/src/tools/code_mode/mod.rs
index 26559df62e..6cbc1a2d1c 100644
--- a/codex-rs/core/src/tools/code_mode/mod.rs
+++ b/codex-rs/core/src/tools/code_mode/mod.rs
@@ -30,6 +30,7 @@ use crate::original_image_detail::sanitize_original_image_detail as sanitize_ima
use crate::session::session::Session;
use crate::session::step_context::StepContext;
use crate::session::turn_context::TurnContext;
+use crate::tools::ExecutedToolCallRecorder;
use crate::tools::context::FunctionToolOutput;
use crate::tools::context::SharedTurnDiffTracker;
use crate::tools::context::ToolPayload;
@@ -80,8 +81,9 @@ impl CodeModeService {
pub(crate) fn new(
session_provider: Arc<dyn CodeModeSessionProvider>,
config: &CodeModeConfig,
+ executed_tool_calls: Option<Arc<ExecutedToolCallRecorder>>,
) -> Self {
- let dispatch_broker = Arc::new(CodeModeDispatchBroker::new());
+ let dispatch_broker = Arc::new(CodeModeDispatchBroker::new(executed_tool_calls));
let availability = session_provider.availability();
Self {
session: OnceCell::new(),
@@ -341,12 +343,16 @@ fn truncate_code_mode_result(
truncate_function_output_items_with_policy(&items, policy, estimate_audio_token_count)
}
-async fn call_nested_tool(
+// Submit synchronously so the recorder sees the call before the cell's dispatch gate closes.
+fn submit_nested_tool(
exec: ExecContext,
tool_runtime: ToolCallRuntime,
invocation: CodeModeNestedToolCall,
cancellation_token: CancellationToken,
-) -> Result<JsonValue, FunctionCallError> {
+) -> Result<
+ impl std::future::Future<Output = Result<JsonValue, FunctionCallError>> + Send + 'static,
+ FunctionCallError,
+> {
let CodeModeNestedToolCall {
cell_id,
runtime_tool_call_id,
@@ -380,17 +386,15 @@ async fn call_nested_tool(
call_id: call.call_id.clone(),
cell_id: cell_id.to_string(),
});
- let result = tool_runtime
- .handle_tool_call_with_source(
- call,
- ToolCallSource::CodeMode {
- cell_id: cell_id.to_string(),
- runtime_tool_call_id,
- },
- cancellation_token,
- )
- .await?;
- Ok(result.code_mode_result())
+ let result = tool_runtime.handle_tool_call_with_source(
+ call,
+ ToolCallSource::CodeMode {
+ cell_id: cell_id.to_string(),
+ runtime_tool_call_id,
+ },
+ cancellation_token,
+ );
+ Ok(async move { Ok(result.await?.code_mode_result()) })
}
fn build_nested_tool_payload(
diff --git a/codex-rs/core/src/tools/executed_tool_calls.rs b/codex-rs/core/src/tools/executed_tool_calls.rs
index f16363fe83..cda42c5a13 100644
--- a/codex-rs/core/src/tools/executed_tool_calls.rs
+++ b/codex-rs/core/src/tools/executed_tool_calls.rs
@@ -3,6 +3,7 @@ use std::collections::HashSet;
use codex_code_mode::CellId;
use codex_protocol::models::ExecutedToolCall;
+use codex_protocol::models::ExecutedToolCallArguments;
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;
@@ -30,14 +31,70 @@ struct ExecutedToolCallRecorderState {
direct_calls: HashMap<String, ExecutedToolCall>,
cells: HashMap<CellId, RecordedCell>,
output_cells: HashMap<String, CellId>,
- retained_calls: HashMap<(std::mem::Discriminant<ResponseItem>, String), Vec<ExecutedToolCall>>,
+ retained_calls: HashMap<(std::mem::Discriminant<ResponseItem>, String), RetainedToolCalls>,
pending_nested_calls: usize,
}
+/// Keep each output's calls and completion marker together through replay and pruning.
+#[derive(Default)]
+struct RetainedToolCalls {
+ calls: Vec<ExecutedToolCall>,
+ complete: bool,
+ cell_id: Option<String>,
+ runtime_cell_id: Option<CellId>,
+}
+
+#[derive(Default, PartialEq, Eq)]
+enum CellCompletion {
+ #[default]
+ Unobserved,
+ Started,
+ Recording,
+ Incomplete,
+ Complete,
+}
+
#[derive(Default)]
struct RecordedCell {
pending_calls: Vec<ExecutedToolCall>,
pending_full_argument_bytes: usize,
+ completion: CellCompletion,
+ originating_call_id: Option<String>,
+}
+
+impl ExecutedToolCallRecorderState {
+ fn register_cell(&mut self, cell_id: &CellId, output_call_id: &str) {
+ if self.cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS && !self.cells.contains_key(cell_id)
+ {
+ let output_cells = self.output_cells.values().collect::<HashSet<_>>();
+ let finished_cell = self.cells.iter().find_map(|(id, cell)| {
+ // A finished cell can still have missing or truncated tool call records.
+ (matches!(
+ cell.completion,
+ CellCompletion::Complete | CellCompletion::Incomplete
+ ) && cell.pending_calls.is_empty()
+ && !output_cells.contains(id))
+ .then(|| id.clone())
+ });
+ if let Some(id) = finished_cell {
+ self.cells.remove(&id);
+ }
+ }
+ if (self.cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS
+ && !self.cells.contains_key(cell_id))
+ || (self.output_cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS
+ && !self.output_cells.contains_key(output_call_id))
+ {
+ return;
+ }
+ self.cells
+ .entry(cell_id.clone())
+ .or_default()
+ .originating_call_id
+ .get_or_insert_with(|| output_call_id.to_string());
+ self.output_cells
+ .insert(output_call_id.to_string(), cell_id.clone());
+ }
}
impl ExecutedToolCallRecorder {
@@ -133,6 +190,9 @@ impl ExecutedToolCallRecorder {
|| (state.cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS
&& !state.cells.contains_key(&cell_id))
{
+ if let Some(cell) = state.cells.get_mut(&cell_id) {
+ cell.completion = CellCompletion::Incomplete;
+ }
return;
}
let at_pending_call_limit = state.pending_nested_calls == MAX_PENDING_EXECUTED_TOOL_CALLS;
@@ -151,6 +211,17 @@ impl ExecutedToolCallRecorder {
} else {
ExecutedToolCall::truncated(call.name, original_bytes, max_bytes)
};
+ cell.completion = if matches!(
+ cell.completion,
+ CellCompletion::Started | CellCompletion::Recording
+ ) && !matches!(
+ call.arguments(),
+ ExecutedToolCallArguments::Truncated { .. }
+ ) {
+ CellCompletion::Recording
+ } else {
+ CellCompletion::Incomplete
+ };
cell.pending_calls.push(call);
state.pending_nested_calls += 1;
}
@@ -201,42 +272,71 @@ impl ExecutedToolCallRecorder {
_ => continue,
};
let key = (std::mem::discriminant(&*item), call_id.clone());
+ let retained = state.retained_calls.get(&key);
+ let mut complete = retained.is_some_and(|retained| retained.complete);
+ let mut cell_id = retained.and_then(|retained| retained.cell_id.clone());
+ let mut runtime_cell_id =
+ retained.and_then(|retained| retained.runtime_cell_id.clone());
let calls = if let Some(cached) = retry_cache.get(&key) {
if !pending_retry_outputs.remove(&key) {
continue;
}
pending_retained_outputs.remove(&key);
cached.clone()
- } else if let Some(retained) = state.retained_calls.get(&key) {
+ } else if let Some(retained) = retained {
if !pending_retained_outputs.remove(&key) {
continue;
}
- retained.clone()
+ retained.calls.clone()
} else {
let mut calls = state
.direct_calls
.remove(call_id)
.into_iter()
.collect::<Vec<_>>();
- if let Some(cell_id) = state.output_cells.remove(call_id)
- && let Some(mut cell) = state.cells.remove(&cell_id)
+ if let Some(output_cell_id) = state.output_cells.remove(call_id)
+ && let Some(cell) = state.cells.get_mut(&output_cell_id)
{
- state.pending_nested_calls = state
- .pending_nested_calls
- .saturating_sub(cell.pending_calls.len());
+ 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);
+ cell.pending_full_argument_bytes = 0;
+ complete = cell.completion == CellCompletion::Complete;
+ if matches!(
+ cell.completion,
+ CellCompletion::Complete | CellCompletion::Incomplete
+ ) {
+ state.cells.remove(&output_cell_id);
+ }
+ state.pending_nested_calls =
+ state.pending_nested_calls.saturating_sub(pending_calls);
state
.output_cells
- .retain(|_, output_cell_id| output_cell_id != &cell_id);
- calls.append(&mut cell.pending_calls);
+ .retain(|_, registered_cell_id| registered_cell_id != &output_cell_id);
}
- if calls.is_empty() {
+ if calls.is_empty() && !complete {
continue;
}
retry_cache.insert(key.clone(), calls.clone());
- state.retained_calls.insert(key, calls.clone());
+ state.retained_calls.insert(
+ key,
+ RetainedToolCalls {
+ calls: calls.clone(),
+ complete,
+ cell_id: cell_id.clone(),
+ runtime_cell_id,
+ },
+ );
calls
};
item.append_executed_tool_calls(calls);
+ if let Some(cell_id) = cell_id {
+ item.set_tool_call_cell_id(&cell_id);
+ }
+ if complete {
+ item.mark_tool_calls_complete();
+ }
retained_bytes = retained_bytes.saturating_add(executed_tool_call_metadata_bytes(item));
attached = true;
}
@@ -247,7 +347,7 @@ impl ExecutedToolCallRecorder {
}
if retained_bytes > MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT {
bound_executed_tool_calls_for_prompt_prioritizing_recent(items);
- state.retained_calls.clear();
+ let retained_before_bounding = std::mem::take(&mut state.retained_calls);
for item in items {
let call_id = match &*item {
ResponseItem::FunctionCallOutput {
@@ -261,15 +361,33 @@ impl ExecutedToolCallRecorder {
} => call_id,
_ => continue,
};
- if let Some(calls) = item
- .executed_tool_call_metadata()
- .and_then(|metadata| metadata.executed_tool_calls.as_ref())
- .filter(|calls| !calls.is_empty())
+ 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 Some(runtime_cell_id) = &retained.runtime_cell_id
+ && metadata.and_then(|metadata| metadata.executed_tool_calls.as_ref())
+ != Some(&retained.calls)
+ && let Some(cell) = state.cells.get_mut(runtime_cell_id)
{
- state.retained_calls.insert(
- (std::mem::discriminant(&*item), call_id.clone()),
- calls.clone(),
- );
+ cell.completion = CellCompletion::Incomplete;
+ }
+ if let Some(metadata) = metadata
+ && (metadata
+ .executed_tool_calls
+ .as_ref()
+ .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 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();
+ if let Some(cell_id) = metadata.cell_id.as_ref() {
+ retained.cell_id = Some(cell_id.clone());
+ }
+ retained.complete |= metadata.tool_calls_complete == Some(true);
}
}
}
@@ -282,17 +400,32 @@ impl ExecutedToolCallRecorder {
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
- if (state.cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS
- && !state.cells.contains_key(cell_id))
- || (state.output_cells.len() >= MAX_PENDING_EXECUTED_TOOL_CALLS
- && !state.output_cells.contains_key(output_call_id))
- {
- return;
+ state.register_cell(cell_id, output_call_id);
+ }
+
+ pub(crate) fn start_cell(&self, cell_id: &CellId, output_call_id: &str) {
+ let mut state = self
+ .state
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ state.register_cell(cell_id, output_call_id);
+ if let Some(cell) = state.cells.get_mut(cell_id) {
+ cell.completion = CellCompletion::Started;
+ }
+ }
+
+ pub(crate) fn finish_cell_recording(&self, cell_id: &CellId) {
+ let mut state = self
+ .state
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ if let Some(cell) = state.cells.get_mut(cell_id) {
+ if cell.completion == CellCompletion::Recording {
+ cell.completion = CellCompletion::Complete;
+ } else if cell.completion != CellCompletion::Complete && cell.pending_calls.is_empty() {
+ state.cells.remove(cell_id);
+ }
}
- state.cells.entry(cell_id.clone()).or_default();
- state
- .output_cells
- .insert(output_call_id.to_string(), cell_id.clone());
}
}
diff --git a/codex-rs/core/src/tools/executed_tool_calls_tests.rs b/codex-rs/core/src/tools/executed_tool_calls_tests.rs
index 6a4a8d6c8a..3a2011aaad 100644
--- a/codex-rs/core/src/tools/executed_tool_calls_tests.rs
+++ b/codex-rs/core/src/tools/executed_tool_calls_tests.rs
@@ -1,9 +1,17 @@
use codex_protocol::models::FunctionCallOutputPayload;
+use codex_protocol::models::ResponseInputItem;
use pretty_assertions::assert_eq;
use serde_json::json;
use super::*;
+fn output(call_id: &str) -> ResponseItem {
+ ResponseItem::from(ResponseInputItem::FunctionCallOutput {
+ call_id: call_id.to_string(),
+ output: FunctionCallOutputPayload::from_text(String::new()),
+ })
+}
+
#[test]
fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
let recorder = ExecutedToolCallRecorder::default();
@@ -24,7 +32,7 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
}
let cell_id = CellId::new("bounded-cell".to_string());
- recorder.register_cell(&cell_id, "bounded-output");
+ recorder.start_cell(&cell_id, "bounded-output");
for _ in 0..MAX_PENDING_EXECUTED_TOOL_CALLS + 2 {
recorder.record_nested_tool_call(
cell_id.clone(),
@@ -84,8 +92,15 @@ fn executed_tool_call_recorder_bounds_pending_calls_and_preserves_overflow() {
internal_chat_message_metadata_passthrough: None,
}];
let mut retry_cache = HashMap::new();
+ recorder.finish_cell_recording(&cell_id);
recorder.attach_pending_to_prompt(&mut items, &mut retry_cache);
+ assert_eq!(
+ items[0]
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.tool_calls_complete),
+ None,
+ );
let calls = items[0]
.executed_tool_call_metadata()
.and_then(|metadata| metadata.executed_tool_calls.as_ref())
@@ -198,7 +213,7 @@ fn executed_tool_call_recorder_bounds_retained_history_and_reports_omissions() {
let retained_bytes = state
.retained_calls
.values()
- .map(serialized_json_bytes)
+ .map(|retained| serialized_json_bytes(&retained.calls))
.sum::<serde_json::Result<usize>>()
.expect("retained calls must serialize");
assert!(retained_bytes <= MAX_EXECUTED_TOOL_CALL_FULL_ARGUMENT_BYTES_PER_OUTPUT);
@@ -219,3 +234,189 @@ fn executed_tool_call_recorder_bounds_retained_history_and_reports_omissions() {
assert!(omitted_calls > 0);
assert_eq!(metadata.len() as u64 + omitted_calls, 512);
}
+
+#[test]
+fn tool_call_completeness_requires_finished_lossless_recording() {
+ for scenario in ["empty", "unobserved", "late_call"] {
+ let recorder = ExecutedToolCallRecorder::default();
+ let cell_id = CellId::new(scenario.to_string());
+ if scenario == "unobserved" {
+ recorder.register_cell(&cell_id, "output");
+ } else {
+ recorder.start_cell(&cell_id, "output");
+ }
+ if scenario == "late_call" {
+ recorder.finish_cell_recording(&cell_id);
+ }
+ if scenario != "empty" {
+ recorder.record_nested_tool_call(
+ cell_id.clone(),
+ ExecutedToolCall::new("nested_tool".to_string(), json!({})),
+ /*original_bytes*/ 2,
+ );
+ }
+ recorder.finish_cell_recording(&cell_id);
+
+ let mut items = [output("output")];
+ recorder.attach_pending_to_prompt(&mut items, &mut HashMap::new());
+ assert_eq!(
+ items[0]
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.tool_calls_complete),
+ None,
+ "{scenario} must not claim complete recording",
+ );
+ }
+}
+
+#[test]
+fn tool_call_completeness_survives_waits_without_changing_deltas() {
+ for truncated in [false, true] {
+ 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();
+ for (index, call_id) in ["exec", "wait-1", "wait-2", "wait-3"]
+ .into_iter()
+ .enumerate()
+ {
+ recorder.register_cell(&cell_id, call_id);
+ let mut expected_output = output(call_id);
+ history.push(expected_output.clone());
+ if index < 2 {
+ // Identical calls are distinct submissions; truncation stays sticky across waits.
+ let original_bytes = if truncated && index == 1 { 9_000 } else { 2 };
+ let call = if original_bytes > MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES {
+ ExecutedToolCall::truncated(
+ "nested_tool".to_string(),
+ original_bytes,
+ MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,
+ )
+ } else {
+ ExecutedToolCall::new("nested_tool".to_string(), json!({}))
+ };
+ recorder.record_nested_tool_call(cell_id.clone(), call.clone(), original_bytes);
+ expected_output.append_executed_tool_calls(vec![call]);
+ } else if index == 3 {
+ recorder.finish_cell_recording(&cell_id);
+ }
+ if index < 2 || index == 3 && !truncated {
+ expected_output.set_tool_call_cell_id("exec");
+ }
+ if index == 3 && !truncated {
+ 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));
+ assert_eq!(prompt, expected);
+ }
+ }
+ let state = recorder.state.lock().unwrap();
+ assert!(state.cells.is_empty());
+ assert_eq!(state.pending_nested_calls, 0);
+ }
+}
+
+#[test]
+fn cell_correlation_uses_originating_exec_across_runtime_restarts() {
+ let runtime_cell_id = CellId::new("1".to_string());
+
+ for originating_call_id in ["first-exec", "resumed-exec"] {
+ let recorder = ExecutedToolCallRecorder::default();
+ recorder.start_cell(&runtime_cell_id, originating_call_id);
+ recorder.record_nested_tool_call(
+ runtime_cell_id.clone(),
+ ExecutedToolCall::new("nested_tool".to_string(), json!({})),
+ /*original_bytes*/ 2,
+ );
+
+ let mut initial = [output(originating_call_id)];
+ recorder.attach_pending_to_prompt(&mut initial, &mut HashMap::new());
+ assert_eq!(
+ initial[0]
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.cell_id.as_deref()),
+ Some(originating_call_id),
+ );
+
+ recorder.register_cell(&runtime_cell_id, "wait");
+ recorder.finish_cell_recording(&runtime_cell_id);
+ let mut final_output = [output("wait")];
+ recorder.attach_pending_to_prompt(&mut final_output, &mut HashMap::new());
+ let metadata = final_output[0]
+ .executed_tool_call_metadata()
+ .expect("completed cell must have metadata");
+ assert_eq!(metadata.cell_id.as_deref(), Some(originating_call_id));
+ assert_eq!(metadata.tool_calls_complete, Some(true));
+ }
+}
+
+#[test]
+fn request_truncation_prevents_completion_after_compaction() {
+ let recorder = ExecutedToolCallRecorder::default();
+ let cell_id = CellId::new("compacted-cell".to_string());
+ recorder.start_cell(&cell_id, "exec");
+
+ let arguments = json!({
+ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES - r#"{"payload":""}"#.len()),
+ });
+ for _ in 0..4 {
+ recorder.record_nested_tool_call(
+ cell_id.clone(),
+ ExecutedToolCall::new("nested_tool".to_string(), arguments.clone()),
+ MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES,
+ );
+ }
+
+ let mut initial = [output("exec")];
+ assert!(recorder.attach_pending_to_prompt(&mut initial, &mut HashMap::new()));
+ assert!(
+ initial[0]
+ .executed_tool_call_metadata()
+ .and_then(|metadata| metadata.executed_tool_calls.as_ref())
+ .is_some_and(|calls| calls.iter().any(|call| matches!(
+ call.arguments(),
+ ExecutedToolCallArguments::Truncated { .. }
+ )))
+ );
+
+ recorder.attach_pending_to_prompt(&mut [], &mut HashMap::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),
+ None,
+ );
+}
+
+#[test]
+fn finished_cells_without_more_waits_do_not_block_new_calls() {
+ let recorder = ExecutedToolCallRecorder::default();
+ let call = ExecutedToolCall::new("nested_tool".to_string(), json!({}));
+ 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.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.finish_cell_recording(&fresh);
+ let mut expected = output("fresh-output");
+ expected.append_executed_tool_calls(vec![call]);
+ expected.set_tool_call_cell_id("fresh-output");
+ expected.mark_tool_calls_complete();
+ let mut items = [output("fresh-output")];
+ assert!(recorder.attach_pending_to_prompt(&mut items, &mut HashMap::new()));
+ assert_eq!(items, [expected]);
+}
diff --git a/codex-rs/core/src/tools/tool_dispatch_trace_tests.rs b/codex-rs/core/src/tools/tool_dispatch_trace_tests.rs
index a06c87d3d3..44c03df82c 100644
--- a/codex-rs/core/src/tools/tool_dispatch_trace_tests.rs
+++ b/codex-rs/core/src/tools/tool_dispatch_trace_tests.rs
@@ -283,6 +283,7 @@ async fn missing_code_mode_wait_traces_only_the_wait_tool_call() -> anyhow::Resu
session.services.code_mode_service = CodeModeService::new(
Arc::new(MissingCellCodeModeSessionProvider),
&turn.config.code_mode,
+ session.services.executed_tool_calls.clone(),
);
attach_test_trace(&mut session, &turn, temp.path())?;
diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs
index 9c9c195a33..90eb2c6d2e 100644
--- a/codex-rs/core/tests/suite/code_mode.rs
+++ b/codex-rs/core/tests/suite/code_mode.rs
@@ -1203,6 +1203,118 @@ async fn mcp_code_mode_exclusion_does_not_change_direct_mode_tool_exposure() ->
Ok(())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[test_case(false, false, false; "disabled")]
+#[test_case(true, false, false; "completed")]
+#[test_case(true, true, false; "yielded")]
+#[test_case(true, false, true; "oversized")]
+async fn code_mode_tool_call_completeness_is_private_and_opt_in(
+ metadata_enabled: bool,
+ yielded: bool,
+ oversized: bool,
+) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let server = responses::start_mock_server().await;
+ let code = if oversized {
+ r#"
+const args = { barrier: { id: "", participants: 1 } };
+args.barrier.id = "x".repeat(8192 - JSON.stringify(args).length);
+for (let index = 0; index < 4; index++) await tools.test_sync_tool(args);
+text("done");
+yield_control();
+await new Promise(() => {});
+"#
+ } else if yielded {
+ r#"await tools.test_sync_tool({}); text("done"); yield_control(); await new Promise(() => {});"#
+ } else {
+ r#"await tools.test_sync_tool({}); text("done");"#
+ };
+ // run_code_mode_turn_with_config enables this feature; production keeps it off by default.
+ let (test, follow_up) =
+ run_code_mode_turn_with_config(&server, "Record a nested tool call", code, move |config| {
+ if !metadata_enabled {
+ config
+ .features
+ .disable(Feature::ExecutedToolCallMetadata)
+ .expect("tool call metadata should be disabled");
+ }
+ if oversized {
+ let _ = config.features.disable(Feature::RemoteCompactionV2);
+ }
+ })
+ .await?;
+
+ let request = follow_up.single_request();
+ let first_output = request.custom_tool_call_output("call-1");
+ let metadata = &first_output["internal_chat_message_metadata_passthrough"];
+ let calls = serde_json::json!([{ "name": "test_sync_tool", "arguments": {} }]);
+ let complete = Value::Bool(true);
+ if oversized {
+ assert!(
+ metadata["executed_tool_calls"]
+ .as_array()
+ .is_some_and(|calls| calls.iter().any(|call| call["arguments"]
+ .get("_codex_executed_tool_call_truncated")
+ .is_some()))
+ );
+ } else {
+ assert_eq!(
+ metadata.get("executed_tool_calls"),
+ metadata_enabled.then_some(&calls),
+ );
+ }
+ assert_eq!(
+ metadata.get("tool_calls_complete"),
+ (metadata_enabled && !yielded && !oversized).then_some(&complete),
+ );
+ assert_eq!(
+ metadata.get("cell_id").and_then(Value::as_str),
+ metadata_enabled.then_some("call-1"),
+ );
+ if yielded || oversized {
+ let first_items = custom_tool_output_items(&request, "call-1");
+ let cell_id = extract_running_cell_id(text_item(&first_items, /*index*/ 0));
+
+ if oversized {
+ responses::mount_compact_user_history_with_summary_once(&server, "compacted history")
+ .await;
+ test.codex.submit(Op::Compact).await?;
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+
+ let wait = responses::mount_function_call_agent_response(
+ &server,
+ "call-2",
+ &serde_json::to_string(&serde_json::json!({
+ "cell_id": cell_id,
+ "terminate": true,
+ }))?,
+ "wait",
+ )
+ .await;
+ test.submit_turn("Finish the compacted cell").await?;
+ let final_request = wait.completion.single_request();
+ assert!(
+ final_request
+ .input()
+ .iter()
+ .all(|item| item["call_id"] != "call-1")
+ );
+ assert!(
+ final_request.function_call_output("call-2")
+ ["internal_chat_message_metadata_passthrough"]
+ .get("tool_calls_complete")
+ .is_none()
+ );
+ }
+ }
+
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn code_mode_only_guides_all_tools_search_and_calls_deferred_app_tools() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -1608,6 +1720,7 @@ async fn code_mode_nested_tool_calls_can_run_in_parallel() -> Result<()> {
.with_model("test-gpt-5.1-codex")
.with_config(move |config| {
let _ = config.features.enable(Feature::CodeMode);
+ let _ = config.features.enable(Feature::ExecutedToolCallMetadata);
});
let test = builder.build(&server).await?;
@@ -2074,13 +2187,16 @@ try {
.await?;
let request = second_mock.single_request();
+ let metadata =
+ &request.custom_tool_call_output("call-1")["internal_chat_message_metadata_passthrough"];
assert_eq!(
- request.custom_tool_call_output("call-1")["internal_chat_message_metadata_passthrough"]["executed_tool_calls"],
+ metadata["executed_tool_calls"],
serde_json::json!([
{"name": "exec_command", "arguments": {}},
]),
"failed nested tool attempts remain private request metadata",
);
+ assert_eq!(metadata["tool_calls_complete"], Value::Bool(true));
let (output, success) = custom_tool_output_body_and_success(&request, "call-1");
assert_ne!(
success,
@@ -2478,6 +2594,7 @@ async fn code_mode_can_run_multiple_yielded_sessions() -> Result<()> {
let server = responses::start_mock_server().await;
let mut builder = test_codex().with_config(move |config| {
let _ = config.features.enable(Feature::CodeMode);
+ let _ = config.features.enable(Feature::ExecutedToolCallMetadata);
});
let test = builder.build(&server).await?;
let session_a_gate = test.workspace_path("code-mode-session-a.ready");
@@ -2487,6 +2604,7 @@ async fn code_mode_can_run_multiple_yielded_sessions() -> Result<()> {
let session_a_code = format!(
r#"
+await tools.exec_command({{ cmd: "printf cell-a" }});
text("session a start");
yield_control();
{session_a_wait}
@@ -2495,6 +2613,7 @@ text("session a done");
);
let session_b_code = format!(
r#"
+await tools.exec_command({{ cmd: "printf cell-b" }});
text("session b start");
yield_control();
{session_b_wait}
@@ -2565,7 +2684,7 @@ text("session b done");
"wait",
&serde_json::to_string(&serde_json::json!({
"cell_id": session_a_id.clone(),
- "yield_time_ms": 1_000,
+ "yield_time_ms": 5_000,
}))?,
),
ev_completed("resp-5"),
@@ -2605,7 +2724,7 @@ text("session b done");
"wait",
&serde_json::to_string(&serde_json::json!({
"cell_id": session_b_id.clone(),
- "yield_time_ms": 1_000,
+ "yield_time_ms": 5_000,
}))?,
),
ev_completed("resp-7"),
@@ -2634,6 +2753,44 @@ text("session b done");
text_item(&fourth_items, /*index*/ 0),
);
assert_eq!(text_item(&fourth_items, /*index*/ 1), "session b done");
+ for (output, originating_call_id, expected_command) in [
+ (
+ first_request.custom_tool_call_output("call-1"),
+ "call-1",
+ Some("printf cell-a"),
+ ),
+ (
+ second_request.custom_tool_call_output("call-2"),
+ "call-2",
+ Some("printf cell-b"),
+ ),
+ (third_request.function_call_output("call-3"), "call-1", None),
+ (
+ fourth_request.function_call_output("call-4"),
+ "call-2",
+ None,
+ ),
+ ] {
+ let metadata = &output["internal_chat_message_metadata_passthrough"];
+ assert_eq!(metadata["cell_id"], serde_json::json!(originating_call_id));
+ assert_eq!(
+ metadata.get("tool_calls_complete").and_then(Value::as_bool),
+ expected_command.is_none().then_some(true),
+ );
+ assert_eq!(
+ metadata
+ .get("executed_tool_calls")
+ .and_then(Value::as_array)
+ .and_then(|calls| {
+ calls.iter().find_map(|call| {
+ call["arguments"]["cmd"]
+ .as_str()
+ .filter(|command| command.starts_with("printf cell-"))
+ })
+ }),
+ expected_command,
+ );
+ }
Ok(())
}
@@ -3333,6 +3490,7 @@ async fn code_mode_interrupt_terminates_active_cells_and_nested_tools() -> Resul
.with_config(|config| {
let _ = config.features.enable(Feature::CodeMode);
let _ = config.features.enable(Feature::CodeModeInterrupt);
+ let _ = config.features.enable(Feature::ExecutedToolCallMetadata);
});
let test = builder.build_with_auto_env(&server).await?;
@@ -3453,6 +3611,12 @@ async fn code_mode_interrupt_terminates_active_cells_and_nested_tools() -> Resul
test.submit_turn("verify interrupted cells and reuse their session")
.await?;
let requests = recovery.requests();
+ let metadata = &requests[0].custom_tool_call_output("call-interrupted")["internal_chat_message_metadata_passthrough"];
+ assert_eq!(
+ metadata["executed_tool_calls"],
+ serde_json::json!([{"name": "test_sync_tool", "arguments": {"sleep_after_ms": 60_000}}]),
+ );
+ assert_eq!(metadata["tool_calls_complete"], Value::Bool(true));
let background_output = function_tool_output_items(&requests[1], "call-wait-background");
assert!(text_item(&background_output, /*index*/ 1).contains("not found"));
let active_output = function_tool_output_items(&requests[2], "call-wait-active");
diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rs
index c7fb57ee61..9005f811a0 100644
--- a/codex-rs/protocol/src/models.rs
+++ b/codex-rs/protocol/src/models.rs
@@ -937,11 +937,23 @@ pub struct InternalChatMessageMetadataPassthrough {
#[schemars(skip)]
#[ts(skip)]
pub content_item_kinds: Option<Vec<ContentItemKind>>,
+ // Ignore input values so requests cannot fake tool call records.
+ /// Host-owned Code Mode cell shared by its `exec` and subsequent `wait` outputs.
+ #[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]
+ #[schemars(skip)]
+ #[ts(skip)]
+ pub cell_id: Option<String>,
/// Warehouse-only Responses metadata, not part of the public app-server protocol.
#[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]
#[schemars(skip)]
#[ts(skip)]
pub executed_tool_calls: Option<Vec<ExecutedToolCall>>,
+ /// Whether the host finished recording this cell's calls without losing calls or arguments.
+ /// This describes the call inventory across the cell's outputs, not tool success.
+ #[serde(default, skip_deserializing, skip_serializing_if = "Option::is_none")]
+ #[schemars(skip)]
+ #[ts(skip)]
+ pub tool_calls_complete: Option<bool>,
}
impl InternalChatMessageMetadataPassthrough {
diff --git a/codex-rs/protocol/src/models/executed_tool_calls.rs b/codex-rs/protocol/src/models/executed_tool_calls.rs
index 668b06e11d..8f504ff05c 100644
--- a/codex-rs/protocol/src/models/executed_tool_calls.rs
+++ b/codex-rs/protocol/src/models/executed_tool_calls.rs
@@ -16,12 +16,28 @@ const INTERNAL_CHAT_MESSAGE_METADATA_PASSTHROUGH_FIELD_BYTES: usize =
fn executed_tool_call_metadata_field_bytes(
metadata: &InternalChatMessageMetadataPassthrough,
) -> usize {
- EXECUTED_TOOL_CALL_METADATA_FIELD_BYTES
- + if metadata.turn_id.is_some() {
- 1
- } else {
- INTERNAL_CHAT_MESSAGE_METADATA_PASSTHROUGH_FIELD_BYTES + 3
- }
+ let fields = InternalChatMessageMetadataPassthrough {
+ cell_id: metadata.cell_id.clone(),
+ tool_calls_complete: metadata.tool_calls_complete,
+ ..Default::default()
+ };
+ let mut bytes =
+ serde_json::to_vec(&fields).map_or(usize::MAX, |fields| fields.len().saturating_sub(2));
+ if metadata.executed_tool_calls.is_some() {
+ bytes = bytes
+ .saturating_add(usize::from(bytes > 0))
+ .saturating_add(EXECUTED_TOOL_CALL_METADATA_FIELD_BYTES);
+ }
+ if bytes == 0 {
+ 0
+ } else if metadata.turn_id.is_some()
+ || metadata.create_time.is_some()
+ || metadata.content_item_kinds.is_some()
+ {
+ bytes + 1
+ } else {
+ bytes + INTERNAL_CHAT_MESSAGE_METADATA_PASSTHROUGH_FIELD_BYTES + 3
+ }
}
/// Returns the exact serialized wire size of an item's attempted-tool metadata.
@@ -29,20 +45,15 @@ pub fn executed_tool_call_metadata_bytes(item: &ResponseItem) -> usize {
let Some(metadata) = item.executed_tool_call_metadata() else {
return 0;
};
- let Some(calls) = metadata
+ metadata
.executed_tool_calls
.as_ref()
- .filter(|calls| !calls.is_empty())
- else {
- return 0;
- };
- serde_json::to_vec(calls)
- .map(|bytes| {
- bytes
- .len()
- .saturating_add(executed_tool_call_metadata_field_bytes(metadata))
+ .map_or(0, |calls| {
+ serde_json::to_vec(calls)
+ .map(|calls| calls.len())
+ .unwrap_or(usize::MAX)
})
- .unwrap_or(usize::MAX)
+ .saturating_add(executed_tool_call_metadata_field_bytes(metadata))
}
/// Bounds attempted-tool metadata fairly across the complete serialized request.
@@ -64,6 +75,7 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
let mut remaining_items = 0_usize;
let mut original_calls = 0_usize;
let mut original_metadata_bytes = 0_usize;
+ let mut truncated = false;
for item in items.iter_mut() {
let Some(calls) = item
@@ -72,6 +84,8 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
.and_then(|metadata| metadata.executed_tool_calls.as_mut())
.filter(|calls| !calls.is_empty())
else {
+ original_metadata_bytes =
+ original_metadata_bytes.saturating_add(executed_tool_call_metadata_bytes(item));
continue;
};
for call in calls {
@@ -86,6 +100,7 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
/*omitted_calls*/ None,
);
}
+ truncated |= call.truncation().is_some();
original_calls = original_calls.saturating_add(1).saturating_add(
call.truncation()
.and_then(|truncation| truncation.omitted_calls)
@@ -97,15 +112,51 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
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() {
+ let item_bytes = executed_tool_call_metadata_bytes(item);
+ if let Some(metadata) = item
+ .internal_chat_message_metadata_passthrough_mut()
+ .and_then(Option::as_mut)
+ && metadata.tool_calls_complete == Some(true)
+ {
+ metadata.tool_calls_complete = None;
+ original_metadata_bytes = original_metadata_bytes.saturating_sub(
+ item_bytes.saturating_sub(executed_tool_call_metadata_bytes(item)),
+ );
+ }
+ }
+ }
+ if original_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {
+ return;
+ }
+
+ // Drop marker-only waits before spending the budget on recorded calls.
+ for item in items.iter_mut() {
+ if item.executed_tool_call_metadata().is_some_and(|metadata| {
+ metadata
+ .executed_tool_calls
+ .as_ref()
+ .is_none_or(Vec::is_empty)
+ }) {
+ original_metadata_bytes =
+ original_metadata_bytes.saturating_sub(executed_tool_call_metadata_bytes(item));
+ item.clear_executed_tool_calls();
+ }
+ }
if original_metadata_bytes <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES {
return;
}
let overflow_fallback = items.iter().enumerate().find_map(|(index, item)| {
- item.executed_tool_call_metadata()
- .and_then(|metadata| metadata.executed_tool_calls.as_ref())
- .and_then(|calls| calls.first())
- .map(|call| (index, call.clone()))
+ item.executed_tool_call_metadata().and_then(|metadata| {
+ metadata
+ .executed_tool_calls
+ .as_ref()
+ .and_then(|calls| calls.first())
+ .map(|call| (index, call.clone(), metadata.cell_id.clone()))
+ })
});
let omitted_call_reservation = serde_json::to_vec(&serde_json::json!({
@@ -162,7 +213,7 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
}
if represented_calls == 0 {
- if let Some((index, mut call)) = overflow_fallback {
+ if let Some((index, mut call, cell_id)) = overflow_fallback {
let original_bytes = call
.truncation()
.map(|truncation| truncation.original_bytes)
@@ -183,6 +234,9 @@ fn bound_executed_tool_calls_for_prompt_with_priority(
(name_boundary < original_name_bytes).then_some(original_name_bytes),
);
items[index].append_executed_tool_calls(vec![call]);
+ if let Some(cell_id) = cell_id {
+ items[index].set_tool_call_cell_id(&cell_id);
+ }
}
return;
}
@@ -326,21 +380,39 @@ impl ExecutedToolCall {
}
impl ResponseItem {
+ fn ensure_tool_call_metadata(&mut self) -> Option<&mut InternalChatMessageMetadataPassthrough> {
+ self.internal_chat_message_metadata_passthrough_mut()
+ .map(Option::get_or_insert_default)
+ }
+
+ /// Associates host-recorded calls and completeness with their Code Mode cell.
+ pub fn set_tool_call_cell_id(&mut self, cell_id: &str) {
+ if let Some(metadata) = self.ensure_tool_call_metadata() {
+ metadata.cell_id = Some(cell_id.to_string());
+ }
+ }
+
/// Attaches model-attempted tool invocations without replacing existing item metadata.
pub fn append_executed_tool_calls(&mut self, calls: Vec<ExecutedToolCall>) {
if calls.is_empty() {
return;
}
- let Some(metadata) = self.internal_chat_message_metadata_passthrough_mut() else {
+ let Some(metadata) = self.ensure_tool_call_metadata() else {
return;
};
metadata
- .get_or_insert_with(InternalChatMessageMetadataPassthrough::default)
.executed_tool_calls
.get_or_insert_with(Vec::new)
.extend(calls);
}
+ /// Marks a host-owned cell's recorded tool calls as complete.
+ pub fn mark_tool_calls_complete(&mut self) {
+ if let Some(metadata) = self.ensure_tool_call_metadata() {
+ metadata.tool_calls_complete = Some(true);
+ }
+ }
+
/// Returns warehouse-only attempted-tool metadata for any supported item variant.
pub fn executed_tool_call_metadata(&self) -> Option<&InternalChatMessageMetadataPassthrough> {
self.internal_chat_message_metadata_passthrough()
@@ -404,10 +476,7 @@ impl ResponseItem {
});
if calls.is_empty() {
- passthrough.executed_tool_calls = None;
- if *passthrough == InternalChatMessageMetadataPassthrough::default() {
- *metadata = None;
- }
+ self.clear_executed_tool_calls();
}
}
@@ -419,7 +488,9 @@ impl ResponseItem {
let Some(passthrough) = metadata.as_mut() else {
return;
};
+ passthrough.cell_id = None;
passthrough.executed_tool_calls = None;
+ passthrough.tool_calls_complete = None;
if *passthrough == InternalChatMessageMetadataPassthrough::default() {
*metadata = None;
}
diff --git a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs
index e541f56b95..b49443fd11 100644
--- a/codex-rs/protocol/src/models/executed_tool_calls_tests.rs
+++ b/codex-rs/protocol/src/models/executed_tool_calls_tests.rs
@@ -3,6 +3,7 @@ use pretty_assertions::assert_eq;
use super::super::FunctionCallOutputBody;
use super::super::FunctionCallOutputPayload;
+use super::super::ResponseInputItem;
use super::*;
fn passthrough_metadata(turn_id: &str) -> InternalChatMessageMetadataPassthrough {
@@ -43,6 +44,8 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {
String::new(),
serde_json::Value::Null,
)]);
+ item.set_tool_call_cell_id("cell-\"\\");
+ item.mark_tool_calls_complete();
item
})
.collect::<Vec<_>>();
@@ -50,6 +53,12 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {
assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);
bound_executed_tool_calls_for_prompt(&mut items);
assert!(metadata_bytes(&items)? <= MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);
+ for metadata in items
+ .iter()
+ .filter_map(ResponseItem::executed_tool_call_metadata)
+ {
+ assert_eq!(metadata.tool_calls_complete, None);
+ }
let calls = items
.iter()
@@ -94,6 +103,7 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {
oversized_name.clone(),
serde_json::Value::Null,
)]);
+ item.set_tool_call_cell_id("cell-\"\\");
item
})
.collect::<Vec<_>>();
@@ -108,6 +118,13 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {
.collect::<Vec<_>>();
assert_eq!(calls.len(), 1);
let call = calls[0];
+ assert_eq!(
+ oversized_items
+ .iter()
+ .filter_map(ResponseItem::executed_tool_call_metadata)
+ .find_map(|metadata| metadata.cell_id.as_deref()),
+ Some("cell-\"\\"),
+ );
assert_eq!(call.name.len(), MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES / 2);
assert!(oversized_name.starts_with(&call.name));
let truncation = call.truncation().expect("trusted omission marker");
@@ -122,6 +139,29 @@ fn executed_tool_call_prompt_budget_includes_metadata_fields() -> Result<()> {
bound_executed_tool_calls_for_prompt(&mut oversized_items);
assert_eq!(oversized_items, bounded_items);
}
+
+ // 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 {
+ call_id: "wait".to_string(),
+ output: FunctionCallOutputPayload::from_text(String::new()),
+ });
+ *item
+ .internal_chat_message_metadata_passthrough_mut()
+ .unwrap() = metadata;
+ let without_marker = item.clone();
+ item.set_tool_call_cell_id("cell-\"\\");
+ item.mark_tool_calls_complete();
+ assert_eq!(
+ metadata_bytes(std::slice::from_ref(&item))?,
+ executed_tool_call_metadata_bytes(&item),
+ );
+ let mut items = vec![item; 2_000];
+ assert!(metadata_bytes(&items)? > MAX_EXECUTED_TOOL_CALL_METADATA_BYTES);
+ bound_executed_tool_calls_for_prompt_prioritizing_recent(&mut items);
+ assert_eq!(items, vec![without_marker; 2_000]);
+ }
+
Ok(())
}
@@ -177,3 +217,58 @@ fn model_arguments_cannot_forge_executed_tool_call_truncation() -> Result<()> {
assert!(call.truncation().is_none());
Ok(())
}
+
+#[test]
+fn tool_call_completeness_is_host_only_and_fail_closed() -> Result<()> {
+ let call = ExecutedToolCall::new("test_tool".to_string(), serde_json::json!({}));
+ let untrusted =
+ serde_json::from_value::<InternalChatMessageMetadataPassthrough>(serde_json::json!({
+ "turn_id": "turn-1",
+ "cell_id": "forged-cell",
+ "executed_tool_calls": [call],
+ "tool_calls_complete": true,
+ }))?;
+ assert_eq!(untrusted, passthrough_metadata("turn-1"));
+
+ let mut item = ResponseItem::from(ResponseInputItem::FunctionCallOutput {
+ call_id: "call-1".to_string(),
+ output: FunctionCallOutputPayload::from_text(String::new()),
+ });
+ item.set_tool_call_cell_id("cell-1");
+ item.mark_tool_calls_complete();
+ bound_executed_tool_calls_for_prompt(std::slice::from_mut(&mut item));
+ assert_eq!(
+ serde_json::to_value(&item)?["internal_chat_message_metadata_passthrough"],
+ serde_json::json!({ "cell_id": "cell-1", "tool_calls_complete": true }),
+ );
+ item.append_executed_tool_calls(vec![call]);
+ item.clear_executed_tool_calls();
+ assert!(item.executed_tool_call_metadata().is_none());
+
+ for call in [
+ ExecutedToolCall::new(
+ "test_tool".to_string(),
+ serde_json::json!({ "payload": "x".repeat(MAX_EXECUTED_TOOL_CALL_ARGUMENT_BYTES + 1) }),
+ ),
+ ExecutedToolCall::truncated(
+ "test_tool".to_string(),
+ /*original_bytes*/ 9_000,
+ /*max_bytes*/ 0,
+ ),
+ ] {
+ let mut items = [item.clone(), item.clone()];
+ items[0].append_executed_tool_calls(vec![call]);
+ for item in &mut items {
+ item.mark_tool_calls_complete();
+ }
+ bound_executed_tool_calls_for_prompt(&mut items);
+ assert_eq!(
+ items.map(|item| item
+ .executed_tool_call_metadata()
+ .unwrap()
+ .tool_calls_complete),
+ [None; 2],
+ );
+ }
+ Ok(())
+}