Struct Thread 

pub struct Thread {
    pub id: String,
    pub resource_id: Option<String>,
    pub parent_thread_id: Option<String>,
    pub messages: Vec<Arc<Message>>,
    pub state: Value,
    pub patches: Vec<TrackedPatch>,
    pub metadata: ThreadMetadata,
}

Persisted thread state with messages and state history.

Thread uses an owned builder pattern: with_* methods consume self and return a new Thread (e.g., thread.with_message(msg)).

Fields

id: String

Unique thread identifier.

resource_id: Option<String>

Owner/resource identifier (e.g., user_id, org_id).

parent_thread_id: Option<String>

Parent thread identifier (links child → parent for sub-agent lineage).

messages: Vec<Arc<Message>>

Messages (Arc-wrapped for efficient cloning).

state: Value

Initial/snapshot state.

patches: Vec<TrackedPatch>

Patches applied since the last snapshot.

metadata: ThreadMetadata

Metadata.

Implementations

impl Thread

pub fn new(id: impl Into<String>) -> Self

Create a new thread with the given ID.

pub fn with_initial_state(id: impl Into<String>, state: Value) -> Self

Create a new thread with initial state.

pub fn with_resource_id(self, resource_id: impl Into<String>) -> Self

Set the resource_id (pure function, returns new Thread).

pub fn with_parent_thread_id(self, parent_thread_id: impl Into<String>) -> Self

Set the parent_thread_id (pure function, returns new Thread).

pub fn with_message(self, msg: Message) -> Self

Add a message to the thread (pure function, returns new Thread).

Messages are Arc-wrapped for efficient cloning during agent loops.

pub fn with_messages(self, msgs: impl IntoIterator<Item = Message>) -> Self

Add multiple messages (pure function, returns new Thread).

pub fn with_patch(self, patch: TrackedPatch) -> Self

Add a patch to the thread (pure function, returns new Thread).

pub fn with_patches( self, patches: impl IntoIterator<Item = TrackedPatch>, ) -> Self

Add multiple patches (pure function, returns new Thread).

pub fn rebuild_state(&self) -> TireaResult<Value>

Rebuild the current state (base + thread patches).

pub fn replay_to(&self, patch_index: usize) -> TireaResult<Value>

Replay state to a specific patch index (0-based).

• patch_index = 0: Returns state after applying the first patch only
• patch_index = n: Returns state after applying patches 0..=n
• patch_index >= patch_count: Returns error

This enables time-travel debugging by accessing any historical state point.

pub fn snapshot(self) -> TireaResult<Self>

Create a snapshot, collapsing patches into the base state.

Returns a new Thread with the current state as base and empty patches.

pub fn needs_snapshot(&self, threshold: usize) -> bool

Check if a snapshot is needed (e.g., too many patches).

pub fn message_count(&self) -> usize

Get the number of messages.

pub fn patch_count(&self) -> usize

Get the number of patches.

Trait Implementations

impl Clone for Thread

fn clone(&self) -> Thread

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Thread

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Thread

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Thread

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.