Crate a2a_protocol_client 

A2A protocol v1.0 — HTTP client (hyper-backed).

This crate provides A2aClient, a full-featured client for communicating with any A2A-compliant agent over HTTP.

Quick start

use a2a_protocol_client::ClientBuilder;
use a2a_protocol_types::{MessageSendParams, Message, MessageRole, Part, MessageId};

let client = ClientBuilder::new("http://localhost:8080").build()?;

let params = MessageSendParams {
    tenant: None,
    context_id: None,
    message: Message {
        id: MessageId::new("msg-1"),
        role: MessageRole::User,
        parts: vec![Part::text("Hello, agent!")],
        task_id: None,
        context_id: None,
        reference_task_ids: None,
        extensions: None,
        metadata: None,
    },
    configuration: None,
    metadata: None,
};

let response = client.send_message(params).await?;
println!("{response:?}");

Streaming

let mut stream = client.stream_message(params).await?;
while let Some(event) = stream.next().await {
    match event? {
        StreamResponse::StatusUpdate(ev) => {
            println!("State: {:?}", ev.status.state);
        }
        _ => {}
    }
}

Authentication

use a2a_protocol_client::{ClientBuilder, CredentialsStore};
use a2a_protocol_client::auth::{AuthInterceptor, InMemoryCredentialsStore, SessionId};
use std::sync::Arc;

let store = Arc::new(InMemoryCredentialsStore::new());
let session = SessionId::new("session-1");
store.set(session.clone(), "bearer", "my-token".into());

let client = ClientBuilder::new("http://localhost:8080")
    .with_interceptor(AuthInterceptor::new(store, session))
    .build()?;

Agent card discovery

use a2a_protocol_client::discovery::resolve_agent_card;
use a2a_protocol_client::ClientBuilder;

let card = resolve_agent_card("http://localhost:8080").await?;
let client = ClientBuilder::from_card(&card)?.build()?;

Re-exports

pub use auth::AuthInterceptor;

pub use auth::CredentialsStore;

pub use auth::InMemoryCredentialsStore;

pub use auth::SessionId;

pub use builder::ClientBuilder;

pub use client::A2aClient;

pub use config::ClientConfig;

pub use discovery::resolve_agent_card;

pub use error::ClientError;

pub use error::ClientResult;

pub use interceptor::CallInterceptor;

pub use interceptor::ClientRequest;

pub use interceptor::ClientResponse;

pub use interceptor::InterceptorChain;

pub use retry::RetryPolicy;

pub use streaming::EventStream;

pub use transport::GrpcTransport;

pub use transport::WebSocketTransport;

pub use transport::JsonRpcTransport;

pub use transport::RestTransport;

pub use transport::Transport;

Modules

auth

Authentication interceptor and credential storage.

builder

Fluent builder for A2aClient.

client

Core A2aClient struct and constructors.

config

Client configuration types.

discovery

Agent card discovery with HTTP caching.

error

Client error types.

interceptor

Request/response interceptor infrastructure.

methods

Per-method client helpers.

retry

Configurable retry policy for transient client errors.

streaming

SSE client-side streaming support.

tls

TLS connector via rustls.

transport

Transport abstraction for A2A client requests.