Enum RpcEvent 

pub enum RpcEvent {
    MessageUpdate {
        event: AssistantEvent,
    },
    SubagentStart {
        subagent_id: u64,
        agent_name: String,
        task_preview: String,
    },
    SubagentUpdate {
        subagent_id: u64,
        agent_name: String,
        status: String,
    },
    SubagentDone {
        subagent_id: u64,
        agent_name: String,
        result_preview: String,
        duration_secs: f64,
    },
    AgentEnd {
        usage: TurnUsage,
    },
    Response {
        id: String,
        command: String,
        body: Value,
    },
    Error {
        id: Option<String>,
        message: String,
    },
    Ready {
        session_id: String,
        model: String,
        protocol_version: u32,
    },
}

Events emitted by the rpc child to the parent over the child’s stdout.

Variants

MessageUpdate

A streaming update from the assistant (text delta, thinking, tool call lifecycle, …). One or more of these frames precede each RpcEvent::AgentEnd.

Fields

event: AssistantEvent

The granular assistant event payload.

SubagentStart

A subagent has been spawned to handle a delegated task.

Fields

subagent_id: u64

Opaque monotonic id for this subagent instance.

agent_name: String

Human-readable agent name.

task_preview: String

First few words of the task description.

SubagentUpdate

A running subagent has produced an intermediate status update.

Fields

subagent_id: u64

Identifies the subagent (matches a prior RpcEvent::SubagentStart).

agent_name: String

Human-readable agent name.

status: String

Free-form status string (e.g. "running", "tool_call").

SubagentDone

A subagent has finished.

Fields

subagent_id: u64

Identifies the subagent.

agent_name: String

Human-readable agent name.

result_preview: String

First few words of the result.

duration_secs: f64

Wall-clock seconds the subagent ran for.

AgentEnd

The agent turn has completed. Carries final token-usage data.

Fields

usage: TurnUsage

Token usage for the completed turn.

Response

A response to a specific RpcCommand, correlated by id.

The body is flattened into the enclosing JSON object — its keys appear at the top level alongside "type", "id", and "command".

Fields

id: String

Echoed from the originating RpcCommand’s id field.

command: String

The command name this is responding to (e.g. "get_messages").

body: Value

Arbitrary response payload, flattened into the JSON frame.

Type-erased to serde_json::Value for forward-compat with new command strings. Rust consumers wanting strong typing should inspect command and re-deserialise body into a per-command struct.

Error

A protocol-level or runtime error.

id is None for errors not attributable to a specific command (e.g. oversized frame, internal crash).

Fields

id: Option<String>

Correlation id of the command that caused the error, if any.

message: String

Human-readable error description.

Ready

Emitted by the rpc child immediately after startup, before any commands are accepted.

Fields

session_id: String

Unique identifier for this session (UUID or similar).

model: String

The model currently active.

protocol_version: u32

The protocol version implemented by this child. Must equal RPC_PROTOCOL_VERSION for the parent to proceed.

Trait Implementations

impl Clone for RpcEvent

fn clone(&self) -> RpcEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RpcEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RpcEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RpcEvent

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

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 RpcEvent