Enum AgentEvent 

pub enum AgentEvent {
    Thought(String),
    Action {
        tool: String,
        input: String,
    },
    Observation(String),
    Result(String),
    Error(String),
}

A single event emitted by a running agent.

Each variant maps to one stage of the ReAct loop or to an error condition. Serialises to a JSON object with a "type" discriminant field, e.g.:

{"type":"thought","content":"I should search the web."}
{"type":"action","tool":"search","input":"{\"q\":\"Rust\"}"}
{"type":"observation","content":"Rust is a systems language."}
{"type":"result","content":"The answer is 42."}
{"type":"error","content":"Tool not found: foobar"}

Variants

Thought(String)

A reasoning thought produced before taking an action.

Tuple Fields

0: String

The thought text.

Action

An action dispatched to a tool.

Fields

tool: String

The name of the tool being called.

input: String

The serialised input arguments for the tool.

Observation(String)

An observation returned by a tool after an action.

Tuple Fields

0: String

The observation text.

Result(String)

The final result produced by the agent.

Tuple Fields

0: String

The result text.

Error(String)

An error that occurred during agent execution.

Tuple Fields

0: String

A human-readable error description.

Implementations

impl AgentEvent

pub fn to_sse(&self) -> Result<String, AgentRuntimeError>

Serialise the event to an SSE-formatted string: data: {json}\n\n.

Returns an error only if serde_json fails to serialise the value, which cannot happen for this well-formed enum in practice.

pub fn event_type(&self) -> &'static str

Return a short machine-readable event type label.

pub fn is_terminal(&self) -> bool

Return true if this is a terminal event (result or error).

Trait Implementations

impl Clone for AgentEvent

fn clone(&self) -> AgentEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AgentEvent

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

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 AgentEvent

impl StructuralPartialEq for AgentEvent