Struct A2aServer 

pub struct A2aServer { /* private fields */ }

The A2A server: an Application serving the Agent Card and the JSON-RPC endpoint.

Implementations

impl A2aServer

pub fn new(card: AgentCard) -> A2aServer

An agent described by card; until on_message it rejects every message.

pub fn at(self, path: &str) -> A2aServer

The JSON-RPC endpoint’s path (default /a2a).

pub fn on_message<F>(self, handler: F) -> A2aServer

where F: Fn(&A2aContext, Message) -> A2aReply + Send + Sync + 'static,

Answer each message.

pub fn require_bearer(self, token: &str) -> A2aServer

Require Authorization: Bearer <token> on the JSON-RPC endpoint (the card stays public and lists the scheme).

pub fn require_bearer_tokens<'a>( self, tokens: impl IntoIterator<Item = (&'a str, &'a str)>, ) -> A2aServer

Several tokens, each standing for an identity; callers only see their own tasks.

pub fn blocking_timeout(self, timeout: Duration) -> A2aServer

How long SendMessage waits for a running task to finish or ask for input before answering with its current state (default 300 s).

pub fn push_notifications<'a>( self, prefixes: impl IntoIterator<Item = &'a str>, ) -> A2aServer

Turn push notifications on: clients may register webhooks whose URL starts with one of prefixes (https://hooks.example.com/). They come from clients, so only listed destinations are called (SSRF).

pub fn extended_card(self, card: AgentCard) -> A2aServer

A fuller card for authenticated callers (GetExtendedAgentCard): skills you don’t advertise publicly, say. Needs bearer tokens.

pub fn wrap(self, app: impl Application + Send + Sync + 'static) -> A2aServer

Requests that aren’t A2A go to app.

Trait Implementations

impl Application for A2aServer

fn execute( &self, request: &Request, connection: &ConnectionInfo, ) -> Result<Response, String>

Receives a parsed request and returns a fully-built response. Walk your controller list with is_matching / process and return the first match.

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true when executing request is quick and never waits on anything but the local filesystem — health checks, metrics, small static files. The async servers (HTTP/1.1, HTTP/2, HTTP/3) then call execute directly on the event loop, as nginx does, instead of handing the request to tokio’s blocking pool: that handoff (a shared lock and two cross-thread wake-ups) costs more than serving a small file.

fn execute_async<'a>( &'a self, _request: &'a Request, _connection: &'a ConnectionInfo, ) -> Option<AsyncResponse<'a>>

An asynchronous version of execute for this request, when the application has one: the async servers await it on the connection’s task instead of tying up a blocking-pool thread while it waits (the config-driven proxy uses this to wait for a backend without holding a thread). None (the default) means “use execute”. Wrappers return Some only when they add no synchronous work of their own.

fn streams_body(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true to receive this request’s body as a stream (Body::Stream) instead of read into memory first: execute then runs while the body is still arriving, on a blocking-pool thread, and reads it with std::io::Read — a multi-gigabyte upload in a few chunks of memory. Asked after the head is read, so request.body is empty here; decide from the method, path and headers.

impl Clone for A2aServer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.