mirror of
https://github.com/openai/codex.git
synced 2026-05-23 12:34:25 +00:00
f1923a38b1
Begin migrating the thread write codepaths to ThreadStore. This starts using ThreadStore inside of core session code, not only in the app server code. Rework the interfaces around thread recording/persistence. We're left with the following: * `ThreadManager`: owns the process-level registry of loaded threads and handles cross-thread orchestration: start, resume, fork, lookup, remove, and route ops to running CodexThreads. * `CodexThread`: represents one loaded/running thread from the outside. It is the handle app-server and callers use to submit ops, inspect session metadata, and shut the thread down. * `LiveThread`: session-owned persistence lifecycle handle for one active thread. Core session code uses it to append rollout items, materialize lazy persistence, flush, shutdown, discard init-failed writers, and load that thread’s persisted history. * `ThreadStore`: storage backend abstraction. It answers “how are threads persisted, read, listed, updated, archived?” Local and remote implementations live behind this trait. * `LocalThreadStore`: local ThreadStore implementation. It owns the file/sqlite-specific details and keeps RolloutRecorder as a local implementation detail. This is a few too many Thread abstractions for my liking, but they do all represent different concepts / needs / layers. Migration note: in places where the core code explicitly requires a path, rather than a thread ID, throw an error if we're running with a remote store. Cover the new local live-writer lifecycle with focused tests and preserve app-server thread-start behavior, including ephemeral pathless sessions.
77 lines
3.0 KiB
Rust
77 lines
3.0 KiB
Rust
use async_trait::async_trait;
|
|
use codex_protocol::ThreadId;
|
|
use std::any::Any;
|
|
|
|
use crate::AppendThreadItemsParams;
|
|
use crate::ArchiveThreadParams;
|
|
use crate::CreateThreadParams;
|
|
use crate::ListThreadsParams;
|
|
use crate::LoadThreadHistoryParams;
|
|
use crate::ReadThreadParams;
|
|
use crate::ResumeThreadParams;
|
|
use crate::StoredThread;
|
|
use crate::StoredThreadHistory;
|
|
use crate::ThreadPage;
|
|
use crate::ThreadStoreResult;
|
|
use crate::UpdateThreadMetadataParams;
|
|
|
|
/// Storage-neutral thread persistence boundary.
|
|
#[async_trait]
|
|
pub trait ThreadStore: Any + Send + Sync {
|
|
/// Return this store as [`Any`] so callers at API boundaries can reject requests that only
|
|
/// make sense for a concrete store implementation.
|
|
fn as_any(&self) -> &dyn Any;
|
|
|
|
/// Creates a new live thread.
|
|
async fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreResult<()>;
|
|
|
|
/// Reopens an existing thread for live appends.
|
|
async fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreResult<()>;
|
|
|
|
/// Appends items to a live thread.
|
|
async fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreResult<()>;
|
|
|
|
/// Materializes the thread if persistence is lazy, then persists all queued items.
|
|
async fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
|
|
|
|
/// Flushes all queued items and returns once they are durable/readable.
|
|
async fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
|
|
|
|
/// Flushes pending items and closes the live thread writer.
|
|
async fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
|
|
|
|
/// 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<()>;
|
|
|
|
/// Loads persisted history for resume, fork, rollback, and memory jobs.
|
|
async fn load_history(
|
|
&self,
|
|
params: LoadThreadHistoryParams,
|
|
) -> ThreadStoreResult<StoredThreadHistory>;
|
|
|
|
/// Reads a thread summary and optionally its persisted history.
|
|
async fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreResult<StoredThread>;
|
|
|
|
/// Lists stored threads matching the supplied filters.
|
|
async fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreResult<ThreadPage>;
|
|
|
|
/// Applies a mutable metadata patch and returns the updated thread.
|
|
async fn update_thread_metadata(
|
|
&self,
|
|
params: UpdateThreadMetadataParams,
|
|
) -> ThreadStoreResult<StoredThread>;
|
|
|
|
/// Archives a thread.
|
|
async fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreResult<()>;
|
|
|
|
/// Unarchives a thread and returns its updated metadata.
|
|
async fn unarchive_thread(
|
|
&self,
|
|
params: ArchiveThreadParams,
|
|
) -> ThreadStoreResult<StoredThread>;
|
|
}
|