A2A Rust SDK A2A SDK

A2A Rust SDK

a2a-rs is a Rust workspace for the A2A v1 protocol. It includes core protocol types, async client and server libraries, protobuf definitions, and gRPC bindings for building interoperable A2A agents and clients.

The workspace supports:

• JSON-RPC 2.0 over HTTP
• REST / HTTP+JSON
• gRPC via tonic
• SLIMRPC via slim_bindings
• Server-Sent Events for streaming responses
• Protobuf-based interop with other SDKs and runtimes

Workspace

Crate	Purpose
a2a	Core A2A types, errors, events, JSON-RPC types, and wire-compatible serde behavior
a2a-client	Async A2A client with transport abstraction and protocol negotiation from agent cards
a2a-server	Async server framework with REST and JSON-RPC bindings built on axum
a2a-pb	Protobuf schema, generated types, ProtoJSON-capable generated types, and native <-> protobuf conversion helpers
a2a-grpc	gRPC client and server bindings built on tonic
a2a-slimrpc	SLIMRPC client and server bindings built on slim_bindings
a2acli-transport-slimrpc	SLIMRPC transport plugin for the Go a2a-cli, built as a2a-transport-slimrpc
a2acli	Standalone A2A client CLI, published as a2a-cli, for inspecting agent cards, sending messages, managing tasks, and handling push configs
examples/helloworld	Minimal runnable example agent

Supported Bindings

Binding	Client	Server
JSON-RPC	a2a-client	a2a-server
HTTP+JSON / REST	a2a-client	a2a-server
gRPC	a2a-grpc	a2a-grpc
SLIMRPC	a2a-slimrpc; Go a2a-cli via a2acli-transport-slimrpc	a2a-slimrpc

The gRPC support uses the schema in a2a-pb/proto/a2a.proto. The REST and JSON-RPC bindings are intended to stay wire-compatible with other A2A SDKs, including Go and C# implementations.

Requirements

• Rust 1.85 or newer
• A stable rustup toolchain is recommended
• just is optional but useful for common development commands
• cargo-llvm-cov is optional if you want HTML coverage reports

Build And Test

cargo build --workspace
cargo test --workspace

Common project commands are also available through just:

just build
just test
just lint
just fmt-check
just ci

Coverage

Install cargo-llvm-cov once:

cargo install cargo-llvm-cov

Then run:

just coverage

This writes the HTML report to target/llvm-cov/html/index.html.

Running The Example Agent

The hello world example exposes an echo-style agent over REST and JSON-RPC.

cargo run -p helloworld

When the example starts, the following endpoints are available:

• Agent card: http://localhost:3000/.well-known/agent-card.json
• JSON-RPC endpoint: http://localhost:3000/jsonrpc
• REST endpoint: http://localhost:3000/rest

The example does not start a gRPC server, but the a2a-grpc crate provides the client and server bindings needed to add one.

Installing a2acli

Pre-built binaries are available for macOS (arm64, x86_64), Linux (x86_64, aarch64), and Windows (x86_64).

macOS — Homebrew:

brew tap a2aproject/a2a-rs https://github.com/a2aproject/a2a-rs
brew trust a2aproject/a2a-rs
brew install a2acli

Linux — install script:

curl -fsSL https://raw.githubusercontent.com/a2aproject/a2a-rs/main/install.sh | bash

Installs to /usr/local/bin as root or ~/.local/bin otherwise. Override with A2A_CLI_INSTALL_DIR.

Windows — WinGet:

winget install a2aproject.a2acli-rs

From source — via crates.io:

cargo install a2a-cli

Installing The SLIMRPC Transport Plugin

a2a-transport-slimrpc is the SLIMRPC transport plugin for the Go A2A CLI (a2a). The CLI finds it on your PATH and launches it, so the plugin is installed separately from the CLI. Prebuilt binaries are available for macOS (arm64, x86_64), Linux (x86_64, arm64) and Windows (x86_64).

Windows — in PowerShell (not Command Prompt), no administrator rights needed:

irm https://raw.githubusercontent.com/a2aproject/a2a-rs/main/scripts/install-slimrpc-plugin.ps1 | iex

The script installs the latest release. It downloads the Windows archive, checks its SHA-256, copies a2a-transport-slimrpc.exe to %LOCALAPPDATA%\Programs\a2a-transport-slimrpc and adds that folder to your user PATH. Open a new terminal afterwards, since a PATH change only reaches new ones, and check it:

a2a-transport-slimrpc info

It should print JSON containing "name":"slimrpc". If the Go CLI is installed, a2a transport list should now list slimrpc. Set $env:A2A_SLIMRPC_PLUGIN_VERSION = '<version>' before the install command to pin a version, or $env:A2A_SLIMRPC_PLUGIN_INSTALL_DIR to change the folder.

To install without the script, download a2a-transport-slimrpc-v<version>-x86_64-pc-windows-msvc.zip and its .sha256 file from the plugin's release page (releases are tagged a2acli-transport-slimrpc-v<version>), compare (Get-FileHash <zip>).Hash with the .sha256 file, unzip, and copy a2a-transport-slimrpc.exe to a folder on your PATH.

macOS and Linux — see the plugin README: Homebrew on macOS, a release archive on Linux.

Running The A2A CLI

The workspace includes a standalone CLI client built on a2a-client. It resolves the public agent card from a base URL, negotiates JSON-RPC or HTTP+JSON, prints human-readable text by default (-o json for the protocol's own JSON types), and manages task push notification configs.

cargo run --bin a2acli -- card get
cargo run --bin a2acli -- send "hello from rust"
cargo run --bin a2acli -- send "hello from rust" --stream
cargo run --bin a2acli -- task list
cargo run --bin a2acli -- task push-config list task-123

By default the CLI targets http://localhost:3000, which matches the bundled hello world server. Override the target with --agent-card https://host for any compatible A2A server, use --transport jsonrpc or --transport rest to pin transport selection, and pass --bearer, --api-key, or repeated --svc-param Name:Value arguments when the server requires authentication.

Depending On The Workspace

The crates are published on crates.io. To depend on the latest development version directly from Git:

[dependencies]
a2a = { package = "a2a-lf", git = "https://github.com/a2aproject/a2a-rs.git" }
a2a-client = { package = "a2a-client-lf", git = "https://github.com/a2aproject/a2a-rs.git" }
a2a-server = { package = "a2a-server-lf", git = "https://github.com/a2aproject/a2a-rs.git" }
a2a-pb = { package = "a2a-pb", git = "https://github.com/a2aproject/a2a-rs.git" }
a2a-grpc = { package = "a2a-grpc", git = "https://github.com/a2aproject/a2a-rs.git" }
a2a-slimrpc = { package = "a2a-slimrpc", git = "https://github.com/a2aproject/a2a-rs.git" }

Typical usage is:

• a2a for protocol types and serde models
• a2a-client for clients that negotiate REST or JSON-RPC from an agent card
• a2a-server for agent implementations on axum
• a2a-grpc when you need gRPC transport support
• a2a-slimrpc when you need SLIMRPC transport support
• a2a-pb when you need direct access to protobuf messages or conversion helpers

Repository Layout

• a2a/: core protocol crate
• a2a-client/: client transports and factory
• a2a-server/: request handler, routers, streaming, and stores
• a2a-pb/: protobuf schema and conversion layer
• a2a-grpc/: tonic-based bindings
• a2a-slimrpc/: SLIMRPC bindings
• a2acli/: standalone A2A client CLI and published binary package
• a2acli-transport-slimrpc/: SLIMRPC plugin for the Go a2a-cli, with a local gateway and echo-agent example
• examples/helloworld/: runnable sample agent

Contributing

See CONTRIBUTING.md for contribution guidelines, SECURITY.md for security reporting, and CODE_OF_CONDUCT.md for community expectations.

License

Apache-2.0. See LICENSE.md.