Struct BusHandle 

pub struct BusHandle { /* private fields */ }

A scoped handle that a single agent uses to send and receive messages.

The handle knows the agent’s id and uses it as sender_id on outgoing envelopes. It also provides filtered receive helpers.

Implementations

impl BusHandle

pub fn agent_id(&self) -> &str

The agent id this handle belongs to.

pub fn send(&self, topic: impl Into<String>, message: BusMessage) -> usize

Send a message on the given topic.

pub fn send_with_correlation( &self, topic: impl Into<String>, message: BusMessage, correlation_id: Option<String>, ) -> usize

Send a message with a correlation id.

pub fn announce_ready(&self, capabilities: Vec<String>) -> usize

Announce this agent as ready.

pub fn announce_shutdown(&self) -> usize

Announce this agent is shutting down.

pub fn send_task_update( &self, task_id: &str, state: TaskState, message: Option<String>, ) -> usize

Announce a task status update.

pub fn send_artifact_update(&self, task_id: &str, artifact: Artifact) -> usize

Announce an artifact update.

pub fn send_to_agent(&self, to: &str, parts: Vec<Part>) -> usize

Send a direct message to another agent.

pub fn publish_shared_result( &self, key: impl Into<String>, value: Value, tags: Vec<String>, ) -> usize

Publish a shared result (visible to the entire swarm).

pub fn publish_ralph_learning( &self, prd_id: &str, story_id: &str, iteration: usize, learnings: Vec<String>, context: Value, ) -> usize

Publish learnings from a Ralph iteration so other agents / future iterations can build on them.

pub fn publish_ralph_handoff( &self, prd_id: &str, from_story: &str, to_story: &str, context: Value, progress_summary: &str, ) -> usize

Publish a context handoff between sequential Ralph stories.

pub fn publish_ralph_progress( &self, prd_id: &str, passed: usize, total: usize, iteration: usize, status: &str, ) -> usize

Publish PRD-level progress.

pub fn drain_ralph_learnings(&mut self, prd_id: &str) -> Vec<BusEnvelope>

Drain all accumulated Ralph learnings for a PRD (non-blocking).

pub fn send_voice_session_started( &self, room_name: &str, voice_id: &str, ) -> usize

Announce that a voice session has started.

pub fn send_voice_transcript( &self, room_name: &str, text: &str, role: &str, is_final: bool, ) -> usize

Publish a transcript fragment from a voice session.

pub fn send_voice_agent_state(&self, room_name: &str, state: &str) -> usize

Announce a voice agent state change.

pub fn send_voice_session_ended(&self, room_name: &str, reason: &str) -> usize

Announce that a voice session has ended.

pub async fn recv(&mut self) -> Option<BusEnvelope>

Receive the next envelope (blocks until available).

pub async fn recv_topic(&mut self, prefix: &str) -> Option<BusEnvelope>

Receive the next envelope whose topic starts with the given prefix.

pub async fn recv_mine(&mut self) -> Option<BusEnvelope>

Receive the next envelope addressed to this agent.

pub fn try_recv(&mut self) -> Option<BusEnvelope>

Try to receive without blocking. Returns None if no message is queued.

pub fn registry(&self) -> &Arc<AgentRegistry>

Access the agent registry.

pub fn into_receiver(self) -> Receiver<BusEnvelope>

Get mutable access to the underlying receiver. This allows consuming the receiver in stream operations.