From 0d07dae8c9f7b0cd390aa4340fc1376b9d7c2e33 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Mon, 16 Nov 2026 15:51:49 +0000 Subject: [PATCH] Avoid unnecessary rollout item copies during child thread creation (#61833) ## Why Creating a child thread with inherited model context collected owned rollout items just to count them, then collected them again during persistence even when telemetry did not need them. ## What changed Count persisted inherited items without collecting an owned vector. Only collect filtered items during persistence when telemetry is enabled, and reuse those items for metadata updates on normal appends. ## Testing Extend the inherited-context test to verify that paginated history excludes legacy-only events, preserves the child history boundary and record ordinals, and replays the expected records after reopening from disk. GitOrigin-RevId: 04dfb7b5b086c66f4dc760027c4faa704cab0df1 --- codex-rs/thread-store/src/live_thread.rs | 36 +++++++++-------- codex-rs/thread-store/src/local/mod.rs | 50 ++++++++++++++++++++++-- 2 files changed, 67 insertions(+), 19 deletions(-) diff --git a/codex-rs/thread-store/src/live_thread.rs b/codex-rs/thread-store/src/live_thread.rs index a104a15ab5..bb11518b5c 100644 --- a/codex-rs/thread-store/src/live_thread.rs +++ b/codex-rs/thread-store/src/live_thread.rs @@ -8,6 +8,7 @@ use codex_protocol::protocol::ThreadMemoryMode; use codex_rollout::RolloutItem; use codex_rollout::RolloutPersistenceTelemetry; use codex_rollout::measure_and_filter_rollout_items; +use codex_rollout::persisted_rollout_item; use codex_rollout::persisted_rollout_items; use tokio::sync::Mutex; use tracing::warn; @@ -168,8 +169,10 @@ impl LiveThread { inherited_model_context: &[RolloutItem], guard: &mut LiveThreadInitGuard, ) -> ThreadStoreResult { - let persisted_prefix_item_count = - persisted_rollout_items(inherited_model_context, params.history_mode).len(); + let persisted_prefix_item_count = inherited_model_context + .iter() + .filter(|item| persisted_rollout_item(item, params.history_mode).is_some()) + .count(); params.subagent_history_start_ordinal = Some( u64::try_from(persisted_prefix_item_count) .map_err(|_| ThreadStoreError::Internal { @@ -236,7 +239,10 @@ impl LiveThread { fields(item_count = raw_items.len()) )] pub async fn append_items(&self, raw_items: &[RolloutItem]) -> ThreadStoreResult<()> { - let items = self.persist_appended_items(raw_items).await?; + let items = self + .persist_appended_items(raw_items) + .await? + .unwrap_or_else(|| persisted_rollout_items(raw_items, self.history_mode)); if items.is_empty() { return Ok(()); } @@ -261,32 +267,30 @@ impl LiveThread { Ok(()) } + /// Returns the filtered items if sampling already needed to collect them. async fn persist_appended_items( &self, raw_items: &[RolloutItem], - ) -> ThreadStoreResult> { + ) -> ThreadStoreResult>> { // Empty appends are intentionally ignored rather than represented as zero-sized batches. if raw_items.is_empty() { - return Ok(Vec::new()); + return Ok(None); } - let (items, measurement) = if self.persistence_telemetry.is_enabled() { - let (items, measurement) = - measure_and_filter_rollout_items(raw_items, self.history_mode); - (items, Some(measurement)) - } else { - (persisted_rollout_items(raw_items, self.history_mode), None) - }; + let measured = self + .persistence_telemetry + .is_enabled() + .then(|| measure_and_filter_rollout_items(raw_items, self.history_mode)); self.thread_store .append_items(AppendThreadItemsParams { thread_id: self.thread_id, items: raw_items.to_vec(), }) .await?; - if let Some(measurement) = measurement.as_ref() { + Ok(measured.map(|(items, measurement)| { self.persistence_telemetry - .record_batch(raw_items, measurement); - } - Ok(items) + .record_batch(raw_items, &measurement); + items + })) } pub async fn persist(&self, context: PersistContext) -> ThreadStoreResult<()> { diff --git a/codex-rs/thread-store/src/local/mod.rs b/codex-rs/thread-store/src/local/mod.rs index 1d3e99fe02..e8c91f8c11 100644 --- a/codex-rs/thread-store/src/local/mod.rs +++ b/codex-rs/thread-store/src/local/mod.rs @@ -942,6 +942,7 @@ mod tests { use codex_protocol::protocol::TurnStartedEvent; use codex_protocol::protocol::UserMessageEvent; use codex_rollout::RolloutItem; + use pretty_assertions::assert_eq; use tempfile::TempDir; use super::*; @@ -1170,7 +1171,7 @@ mod tests { ) .await .expect("state db should initialize"); - let store = Arc::new(LocalThreadStore::new(config, Some(runtime.clone()))); + let store = Arc::new(LocalThreadStore::new(config.clone(), Some(runtime.clone()))); let thread_id = ThreadId::default(); let mut params = create_thread_params(thread_id); params.history_mode = ThreadHistoryMode::Paginated; @@ -1197,11 +1198,13 @@ mod tests { }) }; + let parent = turn_context("parent-model", AskForApproval::Never); + let child = turn_context("child-model", AskForApproval::OnRequest); let mut guard = crate::LiveThreadInitGuard::default(); let live_thread = LiveThread::create_with_inherited_model_context( store, params, - &[turn_context("parent-model", AskForApproval::Never)], + &[user_message_item("legacy-only event"), parent.clone()], &mut guard, ) .await @@ -1219,7 +1222,7 @@ mod tests { assert_eq!(inherited_metadata.model, None); live_thread - .append_items(&[turn_context("child-model", AskForApproval::OnRequest)]) + .append_items(std::slice::from_ref(&child)) .await .expect("append child context"); let child_metadata = runtime @@ -1229,6 +1232,47 @@ mod tests { .expect("sqlite metadata"); assert_eq!(child_metadata.model.as_deref(), Some("child-model")); assert_eq!(child_metadata.approval_mode, "on-request"); + + let path = live_thread.local_rollout_path().await.unwrap().unwrap(); + live_thread.shutdown().await.expect("close child writer"); + let raw = tokio::fs::read_to_string(&path).await.unwrap(); + let mut lines = raw + .lines() + .map(|line| codex_rollout::parse_rollout_line(line).unwrap()); + let header = lines.next().expect("session metadata"); + let RolloutItem::SessionMeta(meta) = &header.item else { + panic!("expected session metadata"); + }; + // Just the persisted parent record precedes the first child record at ordinal 2. + assert_eq!(meta.meta.subagent_history_start_ordinal, Some(2)); + let records: Vec<_> = lines + .map(|line| (line.ordinal, serde_json::json!(line.item))) + .collect(); + assert_eq!( + records, + vec![ + (Some(1), serde_json::json!(parent)), + (Some(2), serde_json::json!(child)) + ] + ); + + let cold_store = LocalThreadStore::new(config, Some(runtime)); + let replay = cold_store + .resume_thread(ResumeThreadParams { + thread_id, + rollout_path: Some(path), + history: None, + history_revision: None, + include_archived: false, + metadata: thread_metadata(), + }) + .await + .expect("resume from disk"); + assert_eq!( + serde_json::json!(*replay), + serde_json::json!([header.item, parent, child]) + ); + cold_store.shutdown_thread(thread_id).await.unwrap(); } #[tokio::test]