Struct ChatTurn 

pub struct ChatTurn {

    pub actor_id: i32,
    pub intent: Option<String>,
    pub invocations: Vec<ToolInvocation>,
    pub is_head: bool,
    pub kind: ChatTurnKind,
    pub model: Option<String>,
    pub parent_id: Option<i32>,
    pub text: Option<String>,
    pub text_html: String,
    pub thinking: Option<String>,
    pub thinking_html: String,
    pub timestamp: Option<String>,
    pub tool_diff: Option<ToolDiff>,
    pub tool_name: Option<String>,
    pub tool_uses: Vec<String>,
}

One linearized turn along the HEAD-ancestor chain. Already classified, optionally pre-rendered to HTML, with tool invocations inlined — the renderer drops in text_html and renders no further.

JSON schema

{
 "description": "One linearized turn along the HEAD-ancestor chain. Already\nclassified, optionally pre-rendered to HTML, with tool invocations\ninlined — the renderer drops in `text_html` and renders no further.",
 "type": "object",
 "required": [
   "actor_id",
   "invocations",
   "is_head",
   "kind",
   "text_html",
   "thinking_html",
   "tool_uses"
 ],
 "properties": {
   "actor_id": {
     "description": "Index into `actors`.",
     "type": "integer",
     "format": "int32",
     "minimum": 0.0
   },
   "intent": {
     "type": [
       "string",
       "null"
     ]
   },
   "invocations": {
     "description": "`tool.invoke` siblings of an assistant step, spliced inline.",
     "type": "array",
     "items": {
       "$ref": "#/components/schemas/ToolInvocation"
     }
   },
   "is_head": {
     "type": "boolean"
   },
   "kind": {
     "$ref": "#/components/schemas/ChatTurnKind"
   },
   "model": {
     "type": [
       "string",
       "null"
     ]
   },
   "parent_id": {
     "description": "Index into `turns` — `i - 1` along the HEAD chain, `None` at the root.",
     "type": [
       "integer",
       "null"
     ],
     "format": "int32",
     "minimum": 0.0
   },
   "text": {
     "type": [
       "string",
       "null"
     ]
   },
   "text_html": {
     "description": "Sanitized HTML for `text`. Empty when `include_html` is false or\n`text` is empty.",
     "type": "string"
   },
   "thinking": {
     "type": [
       "string",
       "null"
     ]
   },
   "thinking_html": {
     "type": "string"
   },
   "timestamp": {
     "type": [
       "string",
       "null"
     ]
   },
   "tool_diff": {
     "description": "For `kind = \"tool\"` only: the first non-empty `change[k].raw`,\npre-split into lines.",
     "oneOf": [
       {
         "type": "null"
       },
       {
         "allOf": [
           {
             "$ref": "#/components/schemas/ToolDiff"
           }
         ]
       }
     ]
   },
   "tool_name": {
     "description": "For `kind = \"tool\"` only: the tool name (`extra.name`).",
     "type": [
       "string",
       "null"
     ]
   },
   "tool_uses": {
     "description": "Tool names from `extra.tool_uses` (string list).",
     "type": "array",
     "items": {
       "type": "string"
     }
   }
 }
}

Fields

actor_id: i32

Index into actors.

intent: Option<String>

invocations: Vec<ToolInvocation>

tool.invoke siblings of an assistant step, spliced inline.

is_head: bool

kind: ChatTurnKind

model: Option<String>

parent_id: Option<i32>

Index into turns — i - 1 along the HEAD chain, None at the root.

text: Option<String>

text_html: String

Sanitized HTML for text. Empty when include_html is false or text is empty.

thinking: Option<String>

thinking_html: String

timestamp: Option<String>

tool_diff: Option<ToolDiff>

For kind = "tool" only: the first non-empty change[k].raw, pre-split into lines.

tool_name: Option<String>

For kind = "tool" only: the tool name (extra.name).

tool_uses: Vec<String>

Tool names from extra.tool_uses (string list).

Trait Implementations

impl Clone for ChatTurn

fn clone(&self) -> ChatTurn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatTurn

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatTurn

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatTurn

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

where __S: Serializer,

Serialize this value into the given Serde serializer.