Struct UserEvent 

pub struct UserEvent {
    pub metadata: EventMetadata,
    pub message: MessageContent,
    pub permission_mode: Option<String>,
    pub is_meta: Option<bool>,
    pub is_compact_summary: Option<bool>,
    pub origin: Option<OriginInfo>,
    pub tool_use_result: Option<ToolUseResult>,
    pub source_tool_assistant_uuid: Option<String>,
}

User message event

Represents messages from:

• Human users (userType = “external”)
• Tool results (has tool_use_result field)

Fields

metadata: EventMetadata

Common event metadata

message: MessageContent

Message content

permission_mode: Option<String>

Permission mode (for file operations)

is_meta: Option<bool>

Marks injected/synthetic turns: local-command caveats and similar harness-generated notices rather than something the human actually typed.

is_compact_summary: Option<bool>

Marks a synthesized conversation-compaction summary turn (the text Claude Code writes back as a user turn to replay a compacted conversation) rather than something the human actually typed.

origin: Option<OriginInfo>

Where this turn came from. Present on newer transcripts; absent on older ones and on several harness-injected shapes that predate this field, so its absence does not by itself mean “human” — only specific present values ("task-notification", "peer") are used, as an exclusion signal.

tool_use_result: Option<ToolUseResult>

Tool result (if this is a tool result message)

Deserialized leniently — see crate::events::tool_result::deserialize_tool_use_result_lenient.

source_tool_assistant_uuid: Option<String>

Links result back to assistant message that invoked tool

Implementations

impl UserEvent

pub fn uuid(&self) -> &str

Get UUID

pub fn parent_uuid(&self) -> Option<&str>

Get parent UUID

pub fn timestamp(&self) -> DateTime<Utc>

Get timestamp

pub fn extract_text_content(&self) -> Option<String>

Extract text content for FTS indexing

pub fn extract_file_paths(&self) -> Vec<String>

Extract file paths mentioned

pub fn extract_tool_names(&self) -> Vec<String>

Extract tool names

pub fn classify_turn(&self) -> UserTurnKind<'_>

Classify this turn’s content for a restore digest.

Excludes, as UserTurnKind::HarnessNotification:

• non-external turns (tool results routed back as user events with userType unset or "internal")
• isMeta turns (harness-injected notices)
• isCompactSummary turns (the synthesized replay of a compacted conversation, written back as a user turn — not human-authored)
• turns whose origin.kind is "task-notification" (a delegated agent’s completion notice) or "peer" (a cross-session message)
• turns whose content is only tool results (no text block at all — handled implicitly, since ContentBlock::as_text only matches text blocks)
• local-command echoes (<local-command-caveat>, <local-command-stdout>, <local-command-stderr>), stray <task-notification>/<system-reminder> text blocks not caught by the structural checks above

Recognizes, as UserTurnKind::SlashCommand: a <command-name> invocation — a real user action, not free text, but not a harness notification either. The caller decides how to render it.

Everything else is UserTurnKind::HumanPrompt — including system-generated notices of a genuine user action, e.g. [Request interrupted by user], which reflect something the human actually did even though the string wasn’t typed character-by-character.

Trait Implementations

impl Clone for UserEvent

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UserEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UserEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for UserEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.