Enum SubagentVisibility 

pub enum SubagentVisibility {
    Attributed,
    Inline,
    Hidden,
}

What a consumer sees of an agent’s subagents.

Attributed — the default, and no transformer at all — sends the stream as the agent emitted it. The other two exist because a client older than @ag-ui/client 0.0.59 rejects the SUBAGENT_* event types while decoding: an unknown field is tolerated, an unknown event type is not, and there is nothing a client can do about it after the fact. A producer with such consumers must not send them, and this is how it does not.

Upstream’s integrations default to inline and make the full surface opt-in. This crate defaults the other way, because a transformer that rewrites the stream is opt-in here like every other: an agent that wrote ctx.subagent(..) meant it, and silently flattening what it said is the kind of surprise the design notes argue against. Flip it per endpoint when your consumers are older:

let runner = Runner::new(MyAgent).transformer(SubagentVisibility::inline());

Variants

Attributed

The full surface: the lifecycle events, and subagentRunId on everything a subagent produced.

Inline

The pre-subagent shape: no lifecycle events and no subagentRunId anywhere — not on events, not on the messages inside MESSAGES_SNAPSHOT or the RUN_STARTED input echo, not on the interrupts a paused run reports. A subagent’s own text arrives as the parent’s work. A *_CHUNK event that named no id is given the one its attribution resolved to, since without the attribution the consumer would resolve it differently.

A subagent’s steps are dropped rather than flattened. A step brackets its own agent’s graph, and as the parent’s it would either collide with an open step of the same name — the common shape: a parent tools step wrapping the delegation and the child’s own tools inside it — or misdescribe the parent’s graph. The lifecycle events were the child’s structure; so are its steps.

Hidden

Only the parent’s own events. Everything a subagent produced is dropped — including the result of a call it requested, even when the parent executed it, since a result for a call the consumer never saw is a protocol error. The converse holds too: a result answering the parent’s call is kept, untagged, whoever executed it — the consumer saw the call, and a call left unanswered in the history is what the next request would carry back.

The one thing kept is the run’s shared state. A STATE_SNAPSHOT or STATE_DELTA a subagent published describes the thread’s state, not the subagent’s work: a client that never saw it would mirror a stale state and send that back on its next request. It goes out with the tag cleared, as the parent’s.

Implementations

impl SubagentVisibility

pub fn filter(self) -> SubagentFilter

The transformer for this mode. Pointless but harmless for Attributed, which passes everything through.

pub fn inline() -> SubagentFilter

The transformer for Inline.

pub fn hidden() -> SubagentFilter

The transformer for Hidden.

Trait Implementations

impl Clone for SubagentVisibility

fn clone(&self) -> SubagentVisibility

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SubagentVisibility

impl Debug for SubagentVisibility

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

Formats the value using the given formatter.

impl Default for SubagentVisibility

fn default() -> SubagentVisibility

Returns the “default value” for a type.

impl Eq for SubagentVisibility

impl Hash for SubagentVisibility

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

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 SubagentVisibility

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