ra2a

ra2a is a Rust SDK for the Agent2Agent (A2A) Protocol, maintained by community developer qntx. A2A is an open standard hosted by the Linux Foundation for interoperable communication between AI Agents, complementary to MCP (agent-to-tool).

Project Nature#

Unofficial A2A Protocol SDK (community implementation); official A2A SDKs are Python/JavaScript/Java/C#/.NET/Golang.

Core Capabilities#

• Full implementation of 11 JSON-RPC methods in A2A v0.3.0 spec
• Event-driven server: AgentExecutor → EventQueue → RequestHandler pipeline
• Composable Axum handlers (a2a_router), user controls routing, listener, TLS, and middleware
• Transport-agnostic client with CallInterceptor middleware and automatic streaming fallback
• gRPC transport support (via tonic/prost)
• Push Notification configuration with HMAC-SHA256 verification
• Pluggable SQL task storage (PostgreSQL/MySQL/SQLite)

Component Structure#

JSON-RPC Method Support#

Feature Flags#

Security Model#

Supports 5 security schemes aligned with OpenAPI 3.0:

Layered Architecture#

Task Lifecycle#

9 states, terminal states are Completed / Failed / Canceled / Rejected:

Submitted → Working → Completed
                   → Failed
                   → Canceled
                   → Rejected
           Input Required ←→ Working
           Auth Required  ←→ Working
Unknown (initial/query state)

Agent Discovery#

Agents publish AgentCard at /.well-known/agent-card.json, describing identity, capabilities, skills, transport, and security requirements.

Installation#

# Basic installation (client + server enabled by default)
ra2a = "0.8"

# Client only
ra2a = { version = "0.8", default-features = false, features = ["client"] }

# With PostgreSQL and telemetry
ra2a = { version = "0.8", features = ["server", "postgresql", "telemetry"] }

# Full features
ra2a = { version = "0.8", features = ["full"] }

Server Example#

use ra2a::{
    server::{AgentExecutor, Event, EventQueue, RequestContext, ServerState, a2a_router},
    types::{AgentCard, Message, Part, Task, TaskState, TaskStatus},
};

struct EchoAgent;

impl AgentExecutor for EchoAgent {
    fn execute<'a>(
        &'a self, ctx: &'a RequestContext, queue: &'a EventQueue,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move {
            let input = ctx.message.as_ref()
                .and_then(ra2a::Message::text_content)
                .unwrap_or_default();
            let mut task = Task::new(&ctx.task_id, &ctx.context_id);
            task.status = TaskStatus::with_message(
                TaskState::Completed,
                Message::agent(vec![Part::text(format!("Echo: {input}"))]),
            );
            queue.send(Event::Task(task))?;
            Ok(())
        })
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let card = AgentCard::new("Echo Agent", "http://localhost:8080");
    let state = ServerState::from_executor(EchoAgent, card);
    let app = axum::Router::new().merge(a2a_router(state));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
    axum::serve(listener, app).await
}

Client Example#

use ra2a::{
    client::Client,
    types::{Message, MessageSendParams, Part, SendMessageResult},
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::from_url("http://localhost:8080")?;
    let msg = Message::user(vec![Part::text("Hello!")]);
    let result = client.send_message(&MessageSendParams::new(msg)).await?;
    Ok(())
}

Use Cases#

• Building A2A-compatible Rust Agent servers
• Implementing A2A clients to connect remote Agents
• High-performance memory-safe Agent-to-Agent communication infrastructure
• Task orchestration and state management in multi-Agent collaboration systems

Pending Information#