Enum Effect 

pub enum Effect {
    Read,
    Idempotent,
    Write,
}

The side-effect classification a tool declares, re-exported from salvor_core so a tool author needs only this crate. Both the hand-written ToolMeta::EFFECT and the Tool derive name it through here. How a tool call may be retried and how it behaves on replay.

Effect classification does not change one thing: on replay, any completed recorded call is read from the log and never re-executed, regardless of its effect class. A completion is immutable history.

Effect classification governs calls that were not completed, the gap between an intent recorded in the log and a completion that never arrived:

• Effect::Read calls re-execute freely.
• Effect::Idempotent calls retry with the same idempotency key.
• Effect::Write calls are never automatically retried and surface for human reconciliation.

Serializes lowercase ("read", "idempotent", "write"), because the wire form is part of the durable event contract.

This type lives in salvor-core because events reference it; salvor-tools consumes it when it defines tool contracts.

Variants

Read

A call with no side effects. If it was not completed, it re-executes freely, because running it again observes state without changing it.

Idempotent

A call safe to repeat under the same idempotency key. If it was not completed, it retries with that same key, so the provider collapses duplicate attempts into one effect.

Write

A call that changes external state and is not safe to repeat blindly. If it was not completed, it is never automatically retried: a crash between the recorded intent and a completion surfaces for human reconciliation rather than a guess about whether the write landed.

Trait Implementations

impl Clone for Effect

fn clone(&self) -> Effect

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Effect

impl Debug for Effect

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Effect

fn deserialize<__D>( __deserializer: __D, ) -> Result<Effect, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Effect

impl Hash for Effect

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Effect

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Effect

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Effect