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 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).

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 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 }

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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