Struct A2AServer 

pub struct A2AServer { /* private fields */ }

A2A Server - wraps an agent and provides handler functions.

The server does NOT start its own HTTP listener. Instead, it provides handle_a2a_request() and get_agent_card() that you can call from any HTTP framework’s route handler.

Tasks are stored through the TaskStore trait so that tasks/get can retrieve them and tasks/cancel can transition their status. When the default in-memory store exceeds its capacity, the least recently updated task is evicted (LRU).

Implementations

impl A2AServer

pub fn new(chain: Arc<dyn BaseChain>) -> Self

Create a new A2A server backed by a BaseChain.

pub fn from_agent(executor: Arc<AgentExecutor>) -> Self

Create a server backed directly by a stateful agent (P1-8).

The AgentExecutor is adapted to the chain interface, so A2A tasks get genuine conversational continuity. Attach memory to the executor (.with_memory(...)) before wrapping for multi-turn state.

pub fn with_store(self, store: Arc<dyn TaskStore>) -> Self

Replace the default in-memory task store with a custom backend (P1-1).

pub fn with_max_tasks(self, max: usize) -> Self

Set the maximum number of tasks before LRU eviction.

Replaces the store with a fresh in-memory store of the given capacity, discarding any tasks stored so far. Call this before sending tasks.

pub fn with_skill_router(self, router: Arc<dyn SkillRouter>) -> Self

Attach a skill router so tasks/send requests with a skillId are dispatched to a different chain (P2-4).

pub fn with_skill_map(self, map: SkillMapRouter) -> Self

Attach a default skill router built from a static skill_id -> chain map (P2-4).

pub fn with_streaming(self, capacity: usize) -> Self

Enable streaming push notifications over an SSE-compatible channel (P2-1).

Creates a broadcast channel with the given capacity and advertises {"sse": true} on the agent card. Subscribe with A2AServer::subscribe.

pub fn subscribe(&self) -> Option<Receiver<TaskPushNotification>>

Subscribe to task push notifications, if streaming is enabled (P2-1).

Returns None when the server was not built with A2AServer::with_streaming.

pub fn with_auth_token(self, token: impl Into<String>) -> Self

Require a bearer token on every request.

Enables authentication on the server and advertises bearer as a supported scheme on the agent card. Requests without a matching Authorization: Bearer <token> header are rejected with a 401.

pub fn with_rate_limiter(self, limiter: Arc<RateLimiter>) -> Self

Attach a rate limiter applied to every incoming request.

pub fn with_task_ttl(self, ttl: Option<Duration>) -> Self

Set the task time-to-live before expiry cleanup (None disables expiry).

pub fn with_background_cleanup(self, interval: Duration) -> Self

Spawn a background sweeper that periodically scans for expired tasks (P1-2), in addition to the lazy cleanup on the read paths.

The loop calls sweep_expired_tasks every interval (clamped to at least 1s). It runs until the current Tokio runtime shuts down. If the server has no TTL configured (with_task_ttl(None)), no task is spawned — there is nothing to expire.

pub fn with_card(self, card: AgentCard) -> Self

Set a custom agent card.

pub fn get_agent_card(&self) -> &AgentCard

Get the agent card (for GET /.well-known/agent-card.json).

pub async fn handle_a2a_request(&self, req: A2ARequest) -> A2AResponse

Handle an incoming A2A request (for POST /).

Applies the optional rate limiter, then dispatches based on the request method:

• tasks/send -> acknowledge a new async task (or continue one)
• tasks/get -> return a stored task
• tasks/cancel -> cancel a stored task
• tasks/list -> list stored tasks
• unknown method -> method_not_found error

pub async fn handle_a2a_request_authenticated( &self, req: A2ARequest, bearer: Option<&str>, ) -> A2AResponse

Handle an incoming request with an optional bearer token.

If the server was configured with A2AServer::with_auth_token, requests without a matching bearer token are rejected with a 401.