Struct EventActions 

pub struct EventActions {
    pub escalate: bool,
    pub skip_summarization: bool,
    pub transfer_to_agent: Option<String>,
    pub state_delta: HashMap<String, Value>,
}

Actions triggered by an event — control flow and state mutations.

Fields

escalate: bool

If true, escalate to a human or parent agent.

skip_summarization: bool

If true, skip summarization of this event’s content.

transfer_to_agent: Option<String>

Transfer control to another agent by name.

state_delta: HashMap<String, Value>

State mutations (delta key → new value).

Deletions travel in here too, under the reserved Self::REMOVED_KEYS entry — see that constant for why they are not spelled as null. State keys are written through Self::encode_key and read back through Self::decode_key, so a state key that collides with a reserved name is carried rather than lost, and Self::FORMAT marks a delta that went through that encoding so a pre-1.0.1 one is read literally.

Implementations

impl EventActions

pub const REMOVED_KEYS: &'static str = "adk:removed"

Reserved state_delta entry carrying the keys an event deleted, as a JSON array of strings.

Deletion needs its own channel because null is a perfectly ordinary value an agent may store deliberately: using it as the tombstone made replay drop a real null, so persistence was not round-trip lossless for valid State. It rides inside state_delta rather than as a sibling field so that EventActions stays constructible by downstream code that already names every field.

State accepts arbitrary keys, so this name is not reserved from applications — it is escaped around them by Self::encode_key. It is only read as a removal list on an event that carries Self::FORMAT.

pub const FORMAT: &'static str = "adk:format"

Reserved state_delta entry marking an event whose keys went through Self::encode_key and whose removals live at Self::REMOVED_KEYS.

Events written before 1.0.1 have no such marker and no escaping: every entry in them is a literal state key, including one that happens to be named adk:removed or to end in :literal. Without this discriminator there is nothing in the delta itself to tell the two eras apart, and decoding a legacy event would shift those keys or read a stored array as a deletion list. Replay therefore decodes only marked events.

A residue is structural: the marker shares the arbitrary key/value space of the deltas it discriminates, so a legacy event that stored exactly Self::FORMAT_VERSION at exactly this key would still be misread. Closing that completely takes a field outside state_delta, which EventActions cannot grow without breaking source compatibility — so the marker value is chosen to make the collision unreachable in practice rather than merely unlikely.

pub const FORMAT_VERSION: &'static str = "gemini-adk/state-delta/1"

Value written at Self::FORMAT by this version.

A sentinel string rather than a version number: a plain 1 is a value an application could conceivably have stored under its own key, whereas this one only appears if someone wrote this crate’s marker by hand.

pub fn transfer(agent_name: impl Into<String>) -> Self

Create actions that transfer to another agent.

pub fn escalate() -> Self

Create actions that escalate.

pub fn state_delta(delta: HashMap<String, Value>) -> Self

Create actions with a state delta.

pub fn state_removed(keys: impl IntoIterator<Item = String>) -> Self

Create actions that remove keys from state.

pub fn mark_format(&mut self)

Stamp Self::FORMAT on this delta, declaring its keys encoded and its Self::REMOVED_KEYS entry a removal list.

pub fn is_format_marked(&self) -> bool

True when this delta carries a Self::FORMAT marker this build understands — i.e. it was written by 1.0.1 or later.

An unmarked delta is a legacy one: every entry in it is a literal state key and it has no removal channel. A marker from a newer format than this build knows also reads as unmarked, so a forward-dated event is replayed literally rather than decoded under the wrong rules.

pub fn removed_keys(&self) -> impl Iterator<Item = &str>

The state keys this event deletes, drawn from Self::REMOVED_KEYS.

Always empty on a delta without Self::FORMAT: a legacy event that happens to hold an array of strings at that key stored it as a value, and replaying it as a deletion list would delete every key it names.

pub fn encode_key(key: &str) -> Cow<'_, str>

Map a state key to the state_delta key that carries it.

Ordinary keys pass through. A key that would land on a reserved entry — adk:removed or adk:format, or an already-escaped form of either followed by any number of :literal suffixes — gains one more :literal. That ladder is injective and never produces a bare reserved name, so both channels stay free without any state key being dropped or overwritten.

pub fn decode_key(key: &str) -> Cow<'_, str>

Inverse of Self::encode_key: recover the state key a state_delta entry carries.

Apply this only to a delta where Self::is_format_marked holds. On a legacy delta every key is already literal, and stripping a :literal suffix there would rename a state key the application chose.

Trait Implementations

impl Clone for EventActions

fn clone(&self) -> EventActions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventActions

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

Formats the value using the given formatter.

impl Default for EventActions

fn default() -> EventActions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EventActions

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EventActions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.