Enum NormalizedLog 

#[non_exhaustive]
pub enum NormalizedLog {
    Message {
        role: Role,
        content: String,
    },
    ToolCall {
        name: String,
        args: Value,
        status: ToolStatus,
        action: ActionType,
    },
    Thinking {
        content: String,
    },
    TokenUsage {
        total: u32,
        limit: u32,
    },
    Error {
        error_type: String,
        message: String,
    },
}

Provider-agnostic log entry produced by a LogNormalizer.

Normalized logs are an intermediate representation between raw provider output and higher-level crate::event::AgentEvent values. The enum is intentionally non-exhaustive for forward compatibility.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Message

Message emitted by user/assistant/system.

Fields

role: Role

Message role.

content: String

Message content.

ToolCall

Tool invocation state update.

Fields

name: String

Tool name.

args: Value

Tool arguments or raw payload.

status: ToolStatus

Tool execution status.

action: ActionType

Unified high-level action metadata.

Thinking

Assistant reasoning/thinking content.

Fields

content: String

Reasoning text.

TokenUsage

Token usage signal.

Fields

total: u32

Total tokens consumed.

limit: u32

Token limit (if available).

Error

Error signal emitted by the source normalizer.

Fields

error_type: String

Stable error category.

message: String

Human-readable error message.

Trait Implementations

impl Clone for NormalizedLog

fn clone(&self) -> NormalizedLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedLog

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NormalizedLog

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NormalizedLog

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

where __S: Serializer,

Serialize this value into the given Serde serializer.