[codex] Remove async_trait from first-party code (#27475)

## Why

First-party async traits should expose their `Send` contracts explicitly
without requiring `async_trait`. This completes the migration pattern
established in #27303 and #27304.

## What changed

- Replaced the remaining first-party `async_trait` traits with native
return-position `impl Future + Send` where statically dispatched and
explicit boxed `Send` futures where object safety is required.
- Kept implementations behavior-preserving, outlining existing async
bodies into inherent methods where that keeps the diff reviewable.
- Removed all direct first-party `async-trait` dependencies and the
workspace dependency declaration.
- Added a cargo-deny policy that permits `async-trait` only through the
remaining transitive wrapper crates.
- Updated `rand` from 0.8.5 to 0.8.6 to resolve RUSTSEC-2026-0097 and
keep the full cargo-deny check passing.

## Validation

- `just test -p codex-exec-server`: 216 passed, 2 skipped.
- `just test -p codex-model-provider`: 39 passed.
- `just test -p codex-core` and `just test`: changed tests passed;
remaining failures are environment-sensitive suites unrelated to this
migration.
- `cargo deny check`
- `just fix`
- `just fmt`
- `cargo shear`
- `just bazel-lock-check`

codex-rs/thread-store/src/in_memory.rs

@@ -5,7 +5,6 @@ use std::sync::Mutex;
 use std::sync::MutexGuard;
 use std::sync::OnceLock;
 
-use async_trait::async_trait;
 use chrono::Utc;
 use codex_protocol::ThreadId;
 use codex_protocol::models::PermissionProfile;
@@ -31,6 +30,7 @@ use crate::ThreadMetadataPatch;
 use crate::ThreadPage;
 use crate::ThreadStore;
 use crate::ThreadStoreError;
+use crate::ThreadStoreFuture;
 use crate::ThreadStoreResult;
 use crate::UpdateThreadMetadataParams;
 
@@ -160,13 +160,6 @@ impl InMemoryThreadStore {
     pub async fn calls(&self) -> InMemoryThreadStoreCalls {
         self.state.lock().await.calls.clone()
     }
-}
-
-#[async_trait]
-impl ThreadStore for InMemoryThreadStore {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
 
     async fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreResult<()> {
         let mut state = self.state.lock().await;
@@ -230,26 +223,6 @@ impl ThreadStore for InMemoryThreadStore {
         Ok(())
     }
 
-    async fn persist_thread(&self, _thread_id: ThreadId) -> ThreadStoreResult<()> {
-        self.state.lock().await.calls.persist_thread += 1;
-        Ok(())
-    }
-
-    async fn flush_thread(&self, _thread_id: ThreadId) -> ThreadStoreResult<()> {
-        self.state.lock().await.calls.flush_thread += 1;
-        Ok(())
-    }
-
-    async fn shutdown_thread(&self, _thread_id: ThreadId) -> ThreadStoreResult<()> {
-        self.state.lock().await.calls.shutdown_thread += 1;
-        Ok(())
-    }
-
-    async fn discard_thread(&self, _thread_id: ThreadId) -> ThreadStoreResult<()> {
-        self.state.lock().await.calls.discard_thread += 1;
-        Ok(())
-    }
-
     async fn load_history(
         &self,
         params: LoadThreadHistoryParams,
@@ -293,7 +266,7 @@ impl ThreadStore for InMemoryThreadStore {
         stored_thread_from_state(&state, thread_id, params.include_history)
     }
 
-    async fn list_threads(&self, _params: ListThreadsParams) -> ThreadStoreResult<ThreadPage> {
+    async fn list_threads(&self) -> ThreadStoreResult<ThreadPage> {
         let mut state = self.state.lock().await;
         state.calls.list_threads += 1;
         let mut items = state
@@ -327,20 +300,6 @@ impl ThreadStore for InMemoryThreadStore {
         stored_thread_from_state(&state, params.thread_id, /*include_history*/ false)
     }
 
-    async fn archive_thread(&self, _params: ArchiveThreadParams) -> ThreadStoreResult<()> {
-        self.state.lock().await.calls.archive_thread += 1;
-        Ok(())
-    }
-
-    async fn unarchive_thread(
-        &self,
-        params: ArchiveThreadParams,
-    ) -> ThreadStoreResult<StoredThread> {
-        let mut state = self.state.lock().await;
-        state.calls.unarchive_thread += 1;
-        stored_thread_from_state(&state, params.thread_id, /*include_history*/ false)
-    }
-
     async fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreResult<()> {
         let mut state = self.state.lock().await;
         state.calls.delete_thread += 1;
@@ -361,6 +320,102 @@ impl ThreadStore for InMemoryThreadStore {
     }
 }
 
+impl ThreadStore for InMemoryThreadStore {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(InMemoryThreadStore::create_thread(self, params))
+    }
+
+    fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(InMemoryThreadStore::resume_thread(self, params))
+    }
+
+    fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(InMemoryThreadStore::append_items(self, params))
+    }
+
+    fn persist_thread(&self, _thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move {
+            self.state.lock().await.calls.persist_thread += 1;
+            Ok(())
+        })
+    }
+
+    fn flush_thread(&self, _thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move {
+            self.state.lock().await.calls.flush_thread += 1;
+            Ok(())
+        })
+    }
+
+    fn shutdown_thread(&self, _thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move {
+            self.state.lock().await.calls.shutdown_thread += 1;
+            Ok(())
+        })
+    }
+
+    fn discard_thread(&self, _thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move {
+            self.state.lock().await.calls.discard_thread += 1;
+            Ok(())
+        })
+    }
+
+    fn load_history(
+        &self,
+        params: LoadThreadHistoryParams,
+    ) -> ThreadStoreFuture<'_, StoredThreadHistory> {
+        Box::pin(InMemoryThreadStore::load_history(self, params))
+    }
+
+    fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(InMemoryThreadStore::read_thread(self, params))
+    }
+
+    fn read_thread_by_rollout_path(
+        &self,
+        params: ReadThreadByRolloutPathParams,
+    ) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(InMemoryThreadStore::read_thread_by_rollout_path(
+            self, params,
+        ))
+    }
+
+    fn list_threads(&self, _params: ListThreadsParams) -> ThreadStoreFuture<'_, ThreadPage> {
+        Box::pin(InMemoryThreadStore::list_threads(self))
+    }
+
+    fn update_thread_metadata(
+        &self,
+        params: UpdateThreadMetadataParams,
+    ) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(InMemoryThreadStore::update_thread_metadata(self, params))
+    }
+
+    fn archive_thread(&self, _params: ArchiveThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move {
+            self.state.lock().await.calls.archive_thread += 1;
+            Ok(())
+        })
+    }
+
+    fn unarchive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(async move {
+            let mut state = self.state.lock().await;
+            state.calls.unarchive_thread += 1;
+            stored_thread_from_state(&state, params.thread_id, /*include_history*/ false)
+        })
+    }
+
+    fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(InMemoryThreadStore::delete_thread(self, params))
+    }
+}
+
 fn stored_thread_from_state(
     state: &InMemoryThreadStoreState,
     thread_id: ThreadId,

codex-rs/thread-store/src/lib.rs

@@ -21,6 +21,7 @@ pub use live_thread::LiveThreadInitGuard;
 pub use local::LocalThreadStore;
 pub use local::LocalThreadStoreConfig;
 pub use store::ThreadStore;
+pub use store::ThreadStoreFuture;
 pub use types::AppendThreadItemsParams;
 pub use types::ArchiveThreadParams;
 pub use types::ClearableField;

codex-rs/thread-store/src/local/mod.rs

@@ -12,7 +12,6 @@ mod update_thread_metadata;
 #[cfg(test)]
 mod test_support;
 
-use async_trait::async_trait;
 use codex_protocol::ThreadId;
 use codex_rollout::RolloutRecorder;
 use codex_rollout::StateDbHandle;
@@ -38,6 +37,7 @@ use crate::ThreadPage;
 use crate::ThreadSearchPage;
 use crate::ThreadStore;
 use crate::ThreadStoreError;
+use crate::ThreadStoreFuture;
 use crate::ThreadStoreResult;
 use crate::UpdateThreadMetadataParams;
 
@@ -166,41 +166,6 @@ impl LocalThreadStore {
             }
         }
     }
-}
-
-#[async_trait]
-impl ThreadStore for LocalThreadStore {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    async fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreResult<()> {
-        live_writer::create_thread(self, params).await
-    }
-
-    async fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreResult<()> {
-        live_writer::resume_thread(self, params).await
-    }
-
-    async fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreResult<()> {
-        live_writer::append_items(self, params).await
-    }
-
-    async fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()> {
-        live_writer::persist_thread(self, thread_id).await
-    }
-
-    async fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()> {
-        live_writer::flush_thread(self, thread_id).await
-    }
-
-    async fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()> {
-        live_writer::shutdown_thread(self, thread_id).await
-    }
-
-    async fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()> {
-        live_writer::discard_thread(self, thread_id).await
-    }
 
     async fn load_history(
         &self,
@@ -245,11 +210,7 @@ impl ThreadStore for LocalThreadStore {
         })
     }
 
-    async fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreResult<StoredThread> {
-        read_thread::read_thread(self, params).await
-    }
-
-    async fn read_thread_by_rollout_path(
+    async fn read_thread_by_rollout_path_params(
         &self,
         params: ReadThreadByRolloutPathParams,
     ) -> ThreadStoreResult<StoredThread> {
@@ -261,38 +222,89 @@ impl ThreadStore for LocalThreadStore {
         )
         .await
     }
+}
 
-    async fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreResult<ThreadPage> {
-        list_threads::list_threads(self, params).await
+impl ThreadStore for LocalThreadStore {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
     }
 
-    async fn search_threads(
+    fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::create_thread(self, params).await })
+    }
+
+    fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::resume_thread(self, params).await })
+    }
+
+    fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::append_items(self, params).await })
+    }
+
+    fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::persist_thread(self, thread_id).await })
+    }
+
+    fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::flush_thread(self, thread_id).await })
+    }
+
+    fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::shutdown_thread(self, thread_id).await })
+    }
+
+    fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { live_writer::discard_thread(self, thread_id).await })
+    }
+
+    fn load_history(
+        &self,
+        params: LoadThreadHistoryParams,
+    ) -> ThreadStoreFuture<'_, StoredThreadHistory> {
+        Box::pin(LocalThreadStore::load_history(self, params))
+    }
+
+    fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(async move { read_thread::read_thread(self, params).await })
+    }
+
+    fn read_thread_by_rollout_path(
+        &self,
+        params: ReadThreadByRolloutPathParams,
+    ) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(LocalThreadStore::read_thread_by_rollout_path_params(
+            self, params,
+        ))
+    }
+
+    fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreFuture<'_, ThreadPage> {
+        Box::pin(async move { list_threads::list_threads(self, params).await })
+    }
+
+    fn search_threads(
         &self,
         params: SearchThreadsParams,
-    ) -> ThreadStoreResult<ThreadSearchPage> {
-        search_threads::search_threads(self, params).await
+    ) -> ThreadStoreFuture<'_, ThreadSearchPage> {
+        Box::pin(async move { search_threads::search_threads(self, params).await })
     }
 
-    async fn update_thread_metadata(
+    fn update_thread_metadata(
         &self,
         params: UpdateThreadMetadataParams,
-    ) -> ThreadStoreResult<StoredThread> {
-        update_thread_metadata::update_thread_metadata(self, params).await
+    ) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(async move { update_thread_metadata::update_thread_metadata(self, params).await })
     }
 
-    async fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreResult<()> {
-        archive_thread::archive_thread(self, params).await
+    fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { archive_thread::archive_thread(self, params).await })
     }
 
-    async fn unarchive_thread(
-        &self,
-        params: ArchiveThreadParams,
-    ) -> ThreadStoreResult<StoredThread> {
-        unarchive_thread::unarchive_thread(self, params).await
+    fn unarchive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, StoredThread> {
+        Box::pin(async move { unarchive_thread::unarchive_thread(self, params).await })
     }
 
-    async fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreResult<()> {
-        delete_thread::delete_thread(self, params).await
+    fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreFuture<'_, ()> {
+        Box::pin(async move { delete_thread::delete_thread(self, params).await })
     }
 }
 

codex-rs/thread-store/src/store.rs

@@ -1,6 +1,7 @@
-use async_trait::async_trait;
 use codex_protocol::ThreadId;
 use std::any::Any;
+use std::future::Future;
+use std::pin::Pin;
 
 use crate::AppendThreadItemsParams;
 use crate::ArchiveThreadParams;
@@ -24,81 +25,89 @@ use crate::ThreadStoreResult;
 use crate::TurnPage;
 use crate::UpdateThreadMetadataParams;
 
+/// Future returned by [`ThreadStore`] operations.
+pub type ThreadStoreFuture<'a, T> = Pin<Box<dyn Future<Output = ThreadStoreResult<T>> + Send + 'a>>;
+
 /// Storage-neutral thread persistence boundary.
-#[async_trait]
 pub trait ThreadStore: Any + Send + Sync {
     /// Return this store as [`Any`] for implementation-owned escape hatches.
     fn as_any(&self) -> &dyn Any;
 
     /// Creates a new live thread.
-    async fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreResult<()>;
+    fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Reopens an existing thread for live appends.
-    async fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreResult<()>;
+    fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Appends raw rollout items to a live thread.
     ///
     /// Implementations should apply the shared rollout persistence policy before writing durable
     /// replay history and before updating any implementation-owned projections.
-    async fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreResult<()>;
+    fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Materializes the thread if persistence is lazy, then persists all queued items.
-    async fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Flushes all queued items and returns once they are durable/readable.
-    async fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Flushes pending items and closes the live thread writer.
-    async fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Discards the live thread writer without forcing pending in-memory items to become durable.
     ///
     /// Core calls this when session initialization fails after a live writer has been created.
     /// Implementations should release any live writer resources for the thread while preserving
     /// already-durable thread data.
-    async fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Loads persisted history for resume, fork, rollback, and memory jobs.
-    async fn load_history(
+    fn load_history(
         &self,
         params: LoadThreadHistoryParams,
-    ) -> ThreadStoreResult<StoredThreadHistory>;
+    ) -> ThreadStoreFuture<'_, StoredThreadHistory>;
 
     /// Reads a thread summary and optionally its persisted history.
-    async fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreResult<StoredThread>;
+    fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Reads a rollout-backed thread by path when the store supports path-addressed lookups.
     ///
     /// Deprecated: new callers should use [`ThreadStore::read_thread`] instead.
-    async fn read_thread_by_rollout_path(
+    fn read_thread_by_rollout_path(
         &self,
         params: ReadThreadByRolloutPathParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    ) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Lists stored threads matching the supplied filters.
-    async fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreResult<ThreadPage>;
+    fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreFuture<'_, ThreadPage>;
 
     /// Searches stored threads and returns search-only preview metadata.
-    async fn search_threads(
+    fn search_threads(
         &self,
         _params: SearchThreadsParams,
-    ) -> ThreadStoreResult<ThreadSearchPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "thread/search",
+    ) -> ThreadStoreFuture<'_, ThreadSearchPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "thread/search",
+            })
         })
     }
 
     /// Lists turns within a stored thread.
-    async fn list_turns(&self, _params: ListTurnsParams) -> ThreadStoreResult<TurnPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "list_turns",
+    fn list_turns(&self, _params: ListTurnsParams) -> ThreadStoreFuture<'_, TurnPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "list_turns",
+            })
         })
     }
 
     /// Lists persisted items within a stored turn.
-    async fn list_items(&self, _params: ListItemsParams) -> ThreadStoreResult<ItemPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "list_items",
+    fn list_items(&self, _params: ListItemsParams) -> ThreadStoreFuture<'_, ItemPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "list_items",
+            })
         })
     }
 
@@ -106,20 +115,17 @@ pub trait ThreadStore: Any + Send + Sync {
     ///
     /// Implementations should apply the supplied fields directly. Policy such as deciding whether
     /// an append-derived preview should be emitted belongs above the store.
-    async fn update_thread_metadata(
+    fn update_thread_metadata(
         &self,
         params: UpdateThreadMetadataParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    ) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Archives a thread.
-    async fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreResult<()>;
+    fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Unarchives a thread and returns its updated metadata.
-    async fn unarchive_thread(
-        &self,
-        params: ArchiveThreadParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    fn unarchive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Deletes a thread's persisted rollout data and associated metadata.
-    async fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreResult<()>;
+    fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreFuture<'_, ()>;
 }