Lightweight coding agent that runs in your terminal
Rust
Return authoritative replay history when resuming a thread (#49599)
felixxia-oaid7b0d4aa6631
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 966ce1f92d..65cabca09d 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1011,9 +1011,10 @@ impl Session {let mcp_auth = persistence_auth.clone();let thread_persistence_fut = async {if config.ephemeral {- Ok::<_, anyhow::Error>((None, LiveThreadInitGuard::new(/*live_thread*/ None)))+ Ok::<_, anyhow::Error>((None, LiveThreadInitGuard::new(/*live_thread*/ None), None))} else {let mut local_guard = LiveThreadInitGuard::default();+ let mut resume_context = None;let mut managed_guard = match &startup {Some(startup) => Some(startup.persistence.lock().await),None => None,@@ -1096,16 +1097,23 @@ impl Session {},},};- guard- .acquire(LiveThread::resume(- Arc::clone(&thread_store),- session_configuration.history_mode,- params,- ))- .await?+ let store = Arc::clone(&thread_store);+ let history_mode = session_configuration.history_mode;+ let (context_tx, context_rx) = tokio::sync::oneshot::channel();+ let live_thread = guard+ .acquire(async move {+ let (live_thread, history) =+ LiveThread::resume(store, history_mode, params).await?;+ // Cancellation still leaves the writer with the acquisition guard.+ let _ = context_tx.send(history);+ Ok(live_thread)+ })+ .await?;+ resume_context = Some(context_rx.await?);+ live_thread}};- Ok((Some(live_thread), local_guard))+ Ok((Some(live_thread), local_guard, resume_context))}}.instrument(info_span!(@@ -1187,39 +1195,16 @@ impl Session {let (thread_persistence_result, state_db_ctx, (auth, mcp_projection)) =tokio::join!(thread_persistence_fut, state_db_fut, auth_and_mcp_fut);- let (live_thread, mut live_thread_init) = thread_persistence_result.map_err(|e| {- error!("failed to initialize thread persistence: {e:#}");- e- })?;+ let (live_thread, mut live_thread_init, resume_context) = thread_persistence_result+ .map_err(|e| {+ error!("failed to initialize thread persistence: {e:#}");+ e+ })?;let session_result: anyhow::Result<Arc<Self>> = async {if let InitialHistory::Resumed(resumed) = &mut initial_history- // A header identifies a stored snapshot. Headerless histories are explicitly- // supplied by callers (for example, imports) and must not be replaced from disk.- && matches!(- resumed.history.first(),- Some(RolloutItem::SessionMeta(meta)) if meta.meta.id == resumed.conversation_id- )- && let Some(live_thread) = live_thread.as_ref()- && thread_store.as_any().is::<LocalThreadStore>()+ && let Some(history) = resume_context{- // The initial snapshot predates writer ownership. A cold goal edit may have- // completed in between, including while V1 resume_agent was loading history.- // Reload under the live writer's ownership before publishing replayed context.- let items = match session_configuration.history_mode {- ThreadHistoryMode::Legacy => {- live_thread.load_history(/*include_archived*/ true).await?.items- }- ThreadHistoryMode::Paginated => {- thread_store- .load_latest_model_context(codex_thread_store::LoadThreadHistoryParams {- thread_id,- include_archived: true,- })- .await?- .items- }- };- resumed.history = Arc::new(items);+ resumed.history = history;}let rollout_path = if let Some(live_thread) = live_thread.as_ref() {live_thread.local_rollout_path().await?diff --git a/codex-rs/core/tests/suite/guardian_persistence_tests.rs b/codex-rs/core/tests/suite/guardian_persistence_tests.rsindex f306967d3a..60a072856a 100644--- a/codex-rs/core/tests/suite/guardian_persistence_tests.rs+++ b/codex-rs/core/tests/suite/guardian_persistence_tests.rs@@ -73,7 +73,7 @@ impl ThreadStore for GatedReviewerStore {}delegate_store_methods! {- fn resume_thread(params: ResumeThreadParams) -> ();+ fn resume_thread(params: ResumeThreadParams) -> Arc<Vec<RolloutItem>>;fn append_items(params: AppendThreadItemsParams) -> ();fn discard_thread(thread_id: ThreadId) -> ();fn load_history(params: LoadThreadHistoryParams) -> StoredThreadHistory;diff --git a/codex-rs/core/tests/suite/multi_agent_restore_tests.rs b/codex-rs/core/tests/suite/multi_agent_restore_tests.rsindex 6e7abcc142..906816fad7 100644--- a/codex-rs/core/tests/suite/multi_agent_restore_tests.rs+++ b/codex-rs/core/tests/suite/multi_agent_restore_tests.rs@@ -10,6 +10,7 @@ use super::request_has_model;use anyhow::Context;use anyhow::Result;use codex_features::Feature;+use codex_history::RolloutItem;use codex_protocol::ThreadId;use codex_protocol::error::CodexErrorDetails;use codex_protocol::protocol::EventMsg;@@ -76,7 +77,7 @@ impl ThreadStore for GatedChildMetadataStore {delegate_store_methods! {fn create_thread(params: CreateThreadParams) -> ();- fn resume_thread(params: ResumeThreadParams) -> ();+ fn resume_thread(params: ResumeThreadParams) -> Arc<Vec<RolloutItem>>;fn append_items(params: AppendThreadItemsParams) -> ();fn flush_thread(thread_id: ThreadId) -> ();fn shutdown_thread(thread_id: ThreadId) -> ();diff --git a/codex-rs/core/tests/suite/pending_input_persistence.rs b/codex-rs/core/tests/suite/pending_input_persistence.rsindex e94db81946..9d84ca5324 100644--- a/codex-rs/core/tests/suite/pending_input_persistence.rs+++ b/codex-rs/core/tests/suite/pending_input_persistence.rs@@ -104,7 +104,7 @@ impl ThreadStore for GatedCheckpointStore {delegate_store_methods! {fn create_thread(params: CreateThreadParams) -> ();- fn resume_thread(params: ResumeThreadParams) -> ();+ fn resume_thread(params: ResumeThreadParams) -> Arc<Vec<RolloutItem>>;fn append_items(params: AppendThreadItemsParams) -> ();fn discard_thread(thread_id: ThreadId) -> ();fn load_history(params: LoadThreadHistoryParams) -> StoredThreadHistory;diff --git a/codex-rs/thread-store/src/in_memory.rs b/codex-rs/thread-store/src/in_memory.rsindex b7a3899260..7b11fab096 100644--- a/codex-rs/thread-store/src/in_memory.rs+++ b/codex-rs/thread-store/src/in_memory.rs@@ -616,20 +616,33 @@ impl InMemoryThreadStore {Ok(())}- async fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreResult<()> {+ async fn resume_thread(+ &self,+ params: ResumeThreadParams,+ ) -> ThreadStoreResult<Arc<Vec<RolloutItem>>> {let mut state = self.state.lock().await;state.calls.resume_thread += 1;if let Some(history) = params.history {- state- .histories- .insert(params.thread_id, Arc::unwrap_or_clone(history));+ if matches!(+ history.first(),+ Some(RolloutItem::SessionMeta(meta)) if meta.meta.id == params.thread_id+ ) {+ state+ .histories+ .entry(params.thread_id)+ .or_insert_with(|| Arc::unwrap_or_clone(history));+ } else {+ state+ .histories+ .insert(params.thread_id, Arc::unwrap_or_clone(history));+ }} else {state.histories.entry(params.thread_id).or_default();}if let Some(rollout_path) = params.rollout_path {state.rollout_paths.insert(rollout_path, params.thread_id);}- Ok(())+ Ok(Arc::new(state.histories[¶ms.thread_id].clone()))}async fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreResult<()> {@@ -900,7 +913,10 @@ impl ThreadStore for InMemoryThreadStore {Box::pin(InMemoryThreadStore::create_thread(self, params))}- fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()> {+ fn resume_thread(+ &self,+ params: ResumeThreadParams,+ ) -> ThreadStoreFuture<'_, Arc<Vec<RolloutItem>>> {Box::pin(InMemoryThreadStore::resume_thread(self, params))}diff --git a/codex-rs/thread-store/src/live_thread.rs b/codex-rs/thread-store/src/live_thread.rsindex f6f57e6dd0..f9bb507fbc 100644--- a/codex-rs/thread-store/src/live_thread.rs+++ b/codex-rs/thread-store/src/live_thread.rs@@ -179,14 +179,13 @@ impl LiveThread {Ok(live_thread)}+ /// Reopens persistence and returns the replay history selected under writer ownership.pub async fn resume(thread_store: Arc<dyn ThreadStore>,history_mode: ThreadHistoryMode,- params: ResumeThreadParams,- ) -> ThreadStoreResult<Self> {+ mut params: ResumeThreadParams,+ ) -> ThreadStoreResult<(Self, Arc<Vec<RolloutItem>>)> {let thread_id = params.thread_id;- let should_load_history = params.history.is_none();- let include_archived = params.include_archived;let metadata = if history_mode == ThreadHistoryMode::Paginated&& let Some(local_store) = thread_store.as_any().downcast_ref::<LocalThreadStore>()&& let Some(state_db) = local_store.state_db().await@@ -200,34 +199,19 @@ impl LiveThread {} else {None};- let mut metadata_sync = ThreadMetadataSync::for_resume(¶ms, metadata.as_ref());- thread_store.resume_thread(params).await?;- if should_load_history {- match thread_store- .load_history(LoadThreadHistoryParams {- thread_id,- include_archived,- })- .await- {- Ok(history) => metadata_sync.record_resume_history(&history.items),- Err(err) => {- if let Err(discard_err) = thread_store.discard_thread(thread_id).await {- warn!(- "failed to discard thread persistence after resume history load failed: {discard_err}"- );- }- return Err(err);- }- }- }- Ok(Self {- thread_id,- history_mode,- thread_store,- metadata_sync: Arc::new(Mutex::new(metadata_sync)),- persistence_telemetry: RolloutPersistenceTelemetry::new(thread_id),- })+ let history = thread_store.resume_thread(params.clone()).await?;+ params.history = Some(Arc::clone(&history));+ let metadata_sync = ThreadMetadataSync::for_resume(¶ms, metadata.as_ref());+ Ok((+ Self {+ thread_id,+ history_mode,+ thread_store,+ metadata_sync: Arc::new(Mutex::new(metadata_sync)),+ persistence_telemetry: RolloutPersistenceTelemetry::new(thread_id),+ },+ history,+ ))}#[tracing::instrument(diff --git a/codex-rs/thread-store/src/local/live_writer.rs b/codex-rs/thread-store/src/local/live_writer.rsindex 6a2d95f2b0..450f0304da 100644--- a/codex-rs/thread-store/src/local/live_writer.rs+++ b/codex-rs/thread-store/src/local/live_writer.rs@@ -1,4 +1,5 @@use std::path::PathBuf;+use std::sync::Arc;use codex_protocol::ThreadId;use codex_protocol::protocol::ThreadHistoryMode;@@ -14,7 +15,7 @@ use super::LocalThreadStore;use super::create_thread;use crate::AppendThreadItemsParams;use crate::CreateThreadParams;-use crate::ReadThreadParams;+use crate::LoadThreadHistoryParams;use crate::ResumeThreadParams;use crate::ThreadStoreError;use crate::ThreadStoreResult;@@ -40,13 +41,42 @@ pub(super) async fn create_thread(pub(super) async fn resume_thread(store: &LocalThreadStore,params: ResumeThreadParams,-) -> ThreadStoreResult<()> {+) -> ThreadStoreResult<Arc<Vec<RolloutItem>>> {let _live_writer_guard = store.live_writer_locks.lock(params.thread_id).await;store.ensure_live_recorder_absent(params.thread_id).await?;let writer_lock = store.acquire_writer_lock(params.thread_id)?;+ let supplied_history = params+ .history+ .as_ref()+ .filter(|history| {+ !matches!(+ history.first(),+ Some(RolloutItem::SessionMeta(meta)) if meta.meta.id == params.thread_id+ )+ })+ .cloned();+ let rollout_path = match params.rollout_path {+ Some(rollout_path) => rollout_path,+ None => {+ let resolved = if params.include_archived {+ super::thread_rollout_resolver::resolve_current_including_archived(+ store,+ params.thread_id,+ )+ .await?+ } else {+ super::thread_rollout_resolver::resolve_current(store, params.thread_id).await?+ };+ resolved+ .ok_or(ThreadStoreError::ThreadNotFound {+ thread_id: params.thread_id,+ })?+ .path+ }+ };let history_mode = if let Some(history) = params.history.as_deref() {canonical_history_mode_from_rollout_items(history)- } else if let Some(rollout_path) = params.rollout_path.as_ref() {+ } else {super::read_thread::read_thread_by_rollout_path(store,rollout_path.clone(),@@ -55,36 +85,6 @@ pub(super) async fn resume_thread().await?.history_mode- } else {- super::read_thread::read_thread(- store,- ReadThreadParams {- thread_id: params.thread_id,- include_archived: params.include_archived,- include_history: false,- },- )- .await?- .history_mode- };- let rollout_path = match (params.rollout_path, params.history) {- (Some(rollout_path), _history) => rollout_path,- (None, history) => {- let thread = super::read_thread::read_thread(- store,- ReadThreadParams {- thread_id: params.thread_id,- include_archived: params.include_archived,- include_history: history.is_none(),- },- )- .await?;- thread- .rollout_path- .ok_or_else(|| ThreadStoreError::Internal {- message: format!("thread {} does not have a rollout path", params.thread_id),- })?- }};let cwd = params.metadata@@ -122,7 +122,29 @@ pub(super) async fn resume_thread(history_mode,writer_lock,)- .await+ .await?;+ if let Some(history) = supplied_history {+ return Ok(history);+ }+ // Resolve through the installed writer so explicit paths and materialized compressed rollouts+ // take precedence over SQLite. Both ownership guards remain held throughout this read.+ let history = super::model_context::load_latest_model_context(+ store,+ LoadThreadHistoryParams {+ thread_id: params.thread_id,+ include_archived: params.include_archived,+ },+ )+ .await;+ if history.is_err() {+ let entry = store.live_recorders.lock().await.remove(¶ms.thread_id);+ if let Some(entry) = entry+ && let Err(err) = entry.recorder.discard().await+ {+ warn!("failed to discard writer after resume history load failed: {err}");+ }+ }+ history.map(|history| Arc::new(history.items))}#[tracing::instrument(diff --git a/codex-rs/thread-store/src/local/mod.rs b/codex-rs/thread-store/src/local/mod.rsindex 05f2d9061d..55822428a1 100644--- a/codex-rs/thread-store/src/local/mod.rs+++ b/codex-rs/thread-store/src/local/mod.rs@@ -44,6 +44,7 @@ mod timestamp_metadata_tests;use codex_protocol::ThreadId;use codex_protocol::protocol::ThreadHistoryMode;+use codex_rollout::RolloutItem;use codex_rollout::RolloutRecorder;use codex_rollout::StateDbHandle;use codex_rollout::WriterLockCoordinator;@@ -526,7 +527,10 @@ impl ThreadStore for LocalThreadStore {})}- fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()> {+ fn resume_thread(+ &self,+ params: ResumeThreadParams,+ ) -> ThreadStoreFuture<'_, Arc<Vec<RolloutItem>>> {Box::pin(async move { live_writer::resume_thread(self, params).await })}@@ -804,6 +808,7 @@ mod tests {use codex_protocol::items::TurnItem;use codex_protocol::items::UserMessageItem;use codex_protocol::models::BaseInstructions;+ use codex_protocol::models::ContentItem;use codex_protocol::models::FunctionCallOutputPayload;use codex_protocol::models::MessagePhase;use codex_protocol::models::ResponseItem;@@ -992,13 +997,14 @@ mod tests {.await.expect("update stale sqlite rollout path");- let resumed = LiveThread::resume(+ let history = Arc::new(vec![user_message_item("bounded suffix")]);+ let (resumed, supplied_history) = LiveThread::resume(store,ThreadHistoryMode::Paginated,ResumeThreadParams {thread_id,rollout_path: Some(rollout_path.clone()),- history: Some(Arc::new(vec![user_message_item("bounded suffix")])),+ history: Some(Arc::clone(&history)),include_archived: false,metadata: ThreadPersistenceMetadata {cwd: Some(home.path().to_path_buf()),@@ -1009,6 +1015,7 @@ mod tests {).await.expect("resume paginated thread from its requested rollout");+ assert!(Arc::ptr_eq(&supplied_history, &history));assert_eq!(resumed.local_rollout_path().await.expect("live rollout"),Some(rollout_path)@@ -1344,7 +1351,7 @@ mod tests {let thread_id = ThreadId::from_string(&uuid.to_string()).expect("valid thread id");let rollout_path =write_session_file(home.path(), "2025-01-03T17-00-00", uuid).expect("session file");- let live_thread = LiveThread::resume(+ let (live_thread, _history) = LiveThread::resume(store,ThreadHistoryMode::Legacy,ResumeThreadParams {@@ -1399,7 +1406,7 @@ mod tests {let thread_id = ThreadId::from_string(&uuid.to_string()).expect("valid thread id");let rollout_path = write_session_file(external_home.path(), "2025-01-03T17-30-00", uuid).expect("external session file");- let live_thread = LiveThread::resume(+ let (live_thread, _history) = LiveThread::resume(store,ThreadHistoryMode::Legacy,ResumeThreadParams {@@ -1529,12 +1536,18 @@ mod tests {}#[tokio::test]- async fn resume_thread_reopens_live_writer_and_appends() {+ async fn resume_thread_reopens_live_writer_and_appends_with_stale_sqlite_path() {let home = TempDir::new().expect("temp dir");let config = test_config(home.path());+ let runtime = codex_state::StateRuntime::init(+ config.sqlite.clone(),+ config.default_model_provider_id.clone(),+ )+ .await+ .expect("state db should initialize");let thread_id = ThreadId::default();- let first_store = LocalThreadStore::new(config.clone(), /*state_db*/ None);+ let first_store = LocalThreadStore::new(config.clone(), Some(runtime.clone()));first_store.create_thread(create_thread_params(thread_id)).await@@ -1563,7 +1576,21 @@ mod tests {.await.expect("shutdown initial writer");- let resumed_store = LocalThreadStore::new(config, /*state_db*/ None);+ let mut builder = codex_state::ThreadMetadataBuilder::new(+ thread_id,+ home.path().join("missing-rollout.jsonl"),+ chrono::Utc::now(),+ SessionSource::Exec,+ );+ builder.history_mode = ThreadHistoryMode::Legacy;+ builder.cwd = home.path().to_path_buf();+ let metadata = builder.build("test-provider");+ runtime+ .upsert_thread(&metadata)+ .await+ .expect("store stale sqlite path");++ let resumed_store = LocalThreadStore::new(config, Some(runtime));resumed_store.resume_thread(ResumeThreadParams {thread_id,@@ -1614,10 +1641,18 @@ mod tests {.live_rollout_path(thread_id).await.expect("load rollout path");+ let mut expected = primary+ .load_latest_model_context(LoadThreadHistoryParams {+ thread_id,+ include_archived: true,+ })+ .await+ .expect("load initial snapshot")+ .items;let resume_params = ResumeThreadParams {thread_id,rollout_path: Some(rollout_path),- history: None,+ history: Some(Arc::new(expected.clone())),include_archived: true,metadata: thread_metadata(),};@@ -1634,14 +1669,35 @@ mod tests {.expect_err("competing resume should fail");assert!(matches!(error, ThreadStoreError::Conflict { .. }));+ let late_edit = RolloutItem::ResponseItem(+ ResponseItem::Message {+ id: None,+ role: "user".to_string(),+ content: vec![ContentItem::InputText {+ text: "edit after the initial snapshot".to_string(),+ }],+ phase: None,+ internal_chat_message_metadata_passthrough: None,+ }+ .into(),+ );+ primary+ .append_items(AppendThreadItemsParams {+ thread_id,+ items: vec![late_edit.clone()],+ })+ .await+ .expect("append before handing off writer ownership");+ expected.push(late_edit);primary.shutdown_thread(thread_id).await.expect("shutdown should release writer ownership");- secondary+ let resumed = secondary.resume_thread(resume_params).await.expect("resume after shutdown should acquire writer ownership");+ assert_eq!(serde_json::json!(*resumed), serde_json::json!(expected));}}diff --git a/codex-rs/thread-store/src/store.rs b/codex-rs/thread-store/src/store.rsindex d67c3b766a..fb7b93803d 100644--- a/codex-rs/thread-store/src/store.rs+++ b/codex-rs/thread-store/src/store.rs@@ -1,8 +1,10 @@use codex_protocol::ThreadId;use codex_protocol::protocol::ThreadHistoryMode;+use codex_rollout::RolloutItem;use std::any::Any;use std::future::Future;use std::pin::Pin;+use std::sync::Arc;use crate::AddThreadAttachmentOutcome;use crate::AddThreadAttachmentParams;@@ -138,8 +140,17 @@ pub trait ThreadStore: Any + Send + Sync {})}- /// Reopens an existing thread for live appends.- fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()>;+ /// Reopens an existing thread for live appends and returns its authoritative replay context.+ ///+ /// Stored snapshots supplied by callers may predate writer acquisition. Implementations must+ /// include writes committed before acquisition in the returned context. Explicitly supplied+ /// histories without a canonical session header retain their import/override semantics.+ /// Returned histories can share the caller's allocation when no refresh is needed.+ /// On failure, implementations must release any writer acquired by this operation.+ fn resume_thread(+ &self,+ params: ResumeThreadParams,+ ) -> ThreadStoreFuture<'_, Arc<Vec<RolloutItem>>>;/// Appends raw rollout items to a live thread.///diff --git a/codex-rs/thread-store/src/types.rs b/codex-rs/thread-store/src/types.rsindex 5030f8864d..4e842556d3 100644--- a/codex-rs/thread-store/src/types.rs+++ b/codex-rs/thread-store/src/types.rs@@ -125,7 +125,8 @@ pub struct ResumeThreadParams {pub thread_id: ThreadId,/// Known local rollout path when the caller resumed from a specific file.pub rollout_path: Option<PathBuf>,- /// Known replay history for the resumed thread, if already loaded by the caller.+ /// Previously loaded replay history. A canonical session header identifies a stored snapshot+ /// that may need refreshing under writer ownership; other histories are explicit overrides.pub history: Option<Arc<Vec<RolloutItem>>>,/// Whether archived threads may be reopened.pub include_archived: bool,