Struct Turn 

pub struct Turn {
    pub conversation_id: String,
    pub role: Role,
    pub content: String,
    pub tool_calls: Vec<ToolCall>,
    pub tool_use_id: Option<String>,
    pub provenance: Provenance,
    pub timestamp: u64,
    pub hlc: Hlc,
    pub op_id: String,
}

One folded, ordered transcript turn — the typed projection of a crate::oplog::Surface::Conversation op.

hlc/op_id are provenance/ordering only (not part of the replayed Message): they record where the turn sits in the causal order and which op produced it (op identity IS turn identity — see the module docs).

Fields

conversation_id: String

Which conversation this turn threads into (DEFAULT_CONVERSATION when the payload names none).

role: Role

user / assistant / tool.

content: String

The turn text (content, falling back to the legacy text field).

tool_calls: Vec<ToolCall>

Assistant tool calls — the REAL car_inference_types::ToolCall type, parsed from the payload. Empty for non-assistant turns or an assistant turn that called no tool.

tool_use_id: Option<String>

For a Tool turn: the id of the tool call this result answers (Message::ToolResult.tool_use_id).

provenance: Provenance

For a Tool turn: whether the result came from outside the trust boundary (car#723).

Carried through the oplog on purpose. A marking that survives the live turn but not a resume is worse than none — the same fetched bytes would come back as trusted after a restart, and the one path where nobody is watching is exactly where that matters. #[serde(default)] reads turns recorded before this field as Internal, which is how they were treated.

timestamp: u64

Turn timestamp (ms) — the recency key B4’s LastN conversation retention orders on.

hlc: Hlc

The causal-order stamp this turn folded with (ordering/provenance).

op_id: String

The op that produced this turn (provenance; the fold identity).

Implementations

impl Turn

pub fn user_payload( conversation_id: &str, content: &str, timestamp: u64, ) -> Value

Build the Conversation op payload for a user turn — append it via DeviceLog::append(scope, Surface::Conversation, payload).

pub fn assistant_payload( conversation_id: &str, content: &str, tool_calls: Vec<Value>, timestamp: u64, ) -> Value

Build the Conversation op payload for an assistant turn. tool_calls are raw ToolCall JSON values ({id?, name, arguments} — how a model or the daemon already holds them); Turn::from_record parses them into the typed ToolCall. Empty for a plain text reply.

pub fn tool_payload( conversation_id: &str, tool_use_id: &str, content: &str, timestamp: u64, ) -> Value

Build the Conversation op payload for a tool-result turn.

pub fn tool_payload_with_provenance( conversation_id: &str, tool_use_id: &str, content: &str, timestamp: u64, provenance: Provenance, ) -> Value

Turn::tool_payload for a result whose bytes came from outside the trust boundary. Separate constructor rather than a defaulted argument so the caller has to say which it is; tool_payload keeps the common case short and every existing call site correct.

pub fn from_record(record: &FoldedRecord) -> Option<Turn>

Project a folded conversation record into a typed Turn. Returns None for a tombstone stub (a retention-dropped entity’s referential placeholder — never a real turn).

Tolerant of both the rich B2 payload (role/content/tool_calls) and the legacy (speaker, text, timestamp) shape the B4 tests use, so one transcript view serves every conversation op ever written.

pub fn to_message(&self) -> Message

Build the REAL car_inference_types::Message for this turn (typed — a shape change to Message is a compile error here). The mapping:

• Role::User → Message::User
• Role::Assistant → Message::Assistant { content, tool_calls }
• Role::Tool → Message::ToolResult { tool_use_id, content, provenance }

Trait Implementations

impl Clone for Turn

fn clone(&self) -> Turn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Turn

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Turn

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Turn

fn eq(&self, other: &Turn) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Turn

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Turn