Struct Cassette 

pub struct Cassette {
    pub cassette_version: String,
    pub agent: String,
    pub inputs: BTreeMap<String, Value>,
    pub interactions: Vec<Interaction>,
    pub tool_calls: Vec<ToolExchange>,
}

Fields

cassette_version: String

agent: String

Fully qualified name of the agent this was recorded against.

inputs: BTreeMap<String, Value>

The inputs the recording was made with.

Kept in the cassette so it is self-contained: replaying needs no side-car file, and there is no way to pair a recording with the wrong inputs and get a confusing digest mismatch instead of a clear one.

interactions: Vec<Interaction>

tool_calls: Vec<ToolExchange>

Tool invocations and what they returned, in the order they happened.

Kept in their own list rather than interleaved with the model exchanges, because the two are matched independently: an agent may call three tools between two asks, and a single ordered stream would make each side’s position depend on the other’s.

A recorded result contains whatever the tool returned. That is the review burden this format adds, and why the build-time secret scan reads cassettes as well as source.

Implementations

impl Cassette

pub fn new(agent: impl Into<String>) -> Cassette

pub fn to_canonical_json(&self) -> String

The canonical encoding: two-space indentation, trailing newline.

Cassettes are checked in and reviewed, so they get the same stability treatment as golden IR.

pub fn from_json(text: &str) -> Result<Cassette, String>

pub fn load(path: impl AsRef<Path>) -> Result<Cassette, String>

pub fn save(&self, path: impl AsRef<Path>) -> Result<(), String>

Trait Implementations

impl Clone for Cassette

fn clone(&self) -> Cassette

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cassette

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Cassette

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Cassette

fn eq(&self, other: &Cassette) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Cassette

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 Cassette