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
This commit is contained in:
Charlie Marsh
2026-11-16 16:07:27 +00:00
committed by copyberry
parent e5839cbc59
commit 0d07dae8c9
2 changed files with 67 additions and 19 deletions
+20 -16
View File
@@ -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<Self> {
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<Vec<RolloutItem>> {
) -> ThreadStoreResult<Option<Vec<RolloutItem>>> {
// 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<()> {
+47 -3
View File
@@ -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]