Struct ReasoningStep 

pub struct ReasoningStep {
    pub index: u32,
    pub kind: ReasoningStepKind,
    pub content_hash: [u8; 32],
    pub timestamp_unix: u64,
    pub metadata_hash: [u8; 32],
}

A single recorded step in an agent’s reasoning trace.

Actual content is never stored — only a Blake3 hash of it. This preserves privacy while maintaining verifiability: an auditor who holds the original content can independently verify its hash matches the recorded step.

Content Hashing

Hash the content before recording:

use a1::provenance::{ReasoningTrace, ReasoningStepKind};

let thought = "I should buy AAPL because ...";
let content_hash = blake3::hash(thought.as_bytes()).into();

trace.record_hashed(ReasoningStepKind::Thought, content_hash, None);

Or use the convenience methods that hash for you:

trace.record(ReasoningStepKind::Thought, thought.as_bytes());
trace.record_tool_call("get_stock_price", r#"{"symbol":"AAPL"}"#.as_bytes());

Fields

index: u32

Position in the trace (0-indexed, monotonically increasing).

kind: ReasoningStepKind

Semantic category of this step.

content_hash: [u8; 32]

Blake3 hash of the actual step content.

timestamp_unix: u64

Unix timestamp when this step was recorded (seconds).

metadata_hash: [u8; 32]

Blake3 hash of optional structured metadata (tool name, model id, etc.). All-zeros when no metadata is associated.

Implementations

impl ReasoningStep

pub fn leaf_hash(&self) -> [u8; 32]

Compute the Merkle leaf hash for this step.

The leaf is a Blake3 keyed hash over all fields in a canonical order, bound to the step index. This ensures that reordering steps changes the Merkle root even if content hashes are identical.

Trait Implementations

impl Clone for ReasoningStep

fn clone(&self) -> ReasoningStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReasoningStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReasoningStep

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ReasoningStep

fn eq(&self, other: &ReasoningStep) -> 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 ReasoningStep

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ReasoningStep

impl StructuralPartialEq for ReasoningStep