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]