Struct AgentRegistry 

pub struct AgentRegistry<'a> { /* private fields */ }

The fused agent registry. Two distinct sources kept apart on purpose: the durable, replayable log card registry (a fold over the registry topic to the latest card per agent, capability that outlives a brief disconnect), and the live connection presence (what an agent advertises right now over AGDX_SET_CLIENT_METADATA, including the inbox topic routing resolves to, gone on disconnect). Build it with Laser::agent_registry, refresh to fold new cards, refresh_presence to pull live presence, then resolve by capability and inbox.

Implementations

impl<'a> AgentRegistry<'a>

pub async fn refresh(&mut self, now_micros: u64) -> Result<usize, LaserError>

Fold every card published since the last refresh into the registry, stamping now_micros as the observation time, and write the result back to the shared per-stream cache (evicting cards stale at now_micros, so the cached set stays bounded by live agents). Returns the number of records folded. A record that is not a status/card/quarantine envelope, or whose body does not decode, is skipped (the registry topic is single-purpose, but a stray record must not poison the fold).

pub fn agents(&self) -> impl Iterator<Item = &RegisteredCard>

Every agent with a folded card, newest observation kept, ordered by agent id (byte order), so every SDK lists and routes in the same order.

pub fn lookup(&self, agent: &AgentId) -> Option<&RegisteredCard>

The latest card for agent, if any.

pub fn resolve(&self, skill_id: &str, now_micros: u64) -> Vec<&RegisteredCard>

Every agent that advertises skill_id, is still fresh at now_micros, and is not advertising itself Unavailable for it. The capability-resolution primitive the router builds on, so a stale or self-declared-unavailable agent is never routed to. Ordered by agent id (byte order), so RoutePolicy::Any and ranking ties pick the same agent in every SDK.

pub fn is_quarantined(&self, agent: &AgentId) -> bool

Whether agent has been quarantined by an operator.

pub fn inbox_for(&self, agent: &AgentId) -> Option<&str>

The inbox topic agent advertised in its live presence, or None when it advertised none (or refresh_presence has not run). The destination an InboxRoute::Advertised route resolves to, so routing never assumes a shared topic name.

pub fn inbox_for_principal( &self, agent: &AgentId, principal: PrincipalId, ) -> Option<&str>

The inbox agent advertised, but only if the connection that advertised it authenticated as user_id. The principal-bound resolve a deployment with an enrolled agent-to-principal mapping uses, so a connection cannot route work to itself by claiming another principal’s agent id. inbox_for is the claim-only resolve for deployments without such a mapping.

pub fn principal_for(&self, agent: &AgentId) -> Option<PrincipalId>

The authenticated principal of the live connection claiming agent. None means no live presence or a substrate that supplied no principal.

pub async fn refresh_presence(&mut self) -> Result<usize, LaserError>

Pull live connection presence and fold it in, keyed by the agent id each connection claims, so inbox_for can resolve a target to where it is consuming right now. Reads every page of the client-metadata discovery command and decodes each connection’s metadata as an AgentPresence, skipping connections whose metadata is absent or is not a presence body (the channel is opaque, a non-agent client advertises any blob). A later connection claiming the same agent id wins, matching last-write presence. Returns the number of presences folded.

Served by Iggy, so it returns a transport error against a Iggy server that lacks the command.