Build multi-agent systems in Rust.

use a2a_rs::adapter::business::Responder;
use a2a_rs::domain::{A2AError, Message, Part, Role, Task, TaskState};

/// Reply with the message in capitals, and finish the task.
struct Shout;

#[async_trait::async_trait]
impl Responder for Shout {
    async fn respond(
        &self,
        message: &Message,
        task: &Task,
    ) -> Result<(Message, TaskState), A2AError> {
        let text: Vec<&str> = message.parts.iter().filter_map(|p| p.get_text()).collect();
        let reply = Message::builder()
            .role(Role::Agent)
            .parts(vec![Part::text(text.join(" ").to_uppercase())])
            .message_id(uuid::Uuid::new_v4().to_string())
            .task_id(task.id.clone())
            .context_id(message.context_id.clone())
            .build();
        Ok((reply, TaskState::Completed))
    }
}

use a2a_rs::adapter::business::ResponderMessageHandler;
use a2a_rs::adapter::{
    ConnectRpcAdapter, HttpServer, InMemoryStreamingHandler, InMemoryTaskStorage,
    SimpleAgentInfo,
};

// Storage, streaming and push delivery are ports; these are the in-memory adapters.
let storage = InMemoryTaskStorage::new();
let streaming = InMemoryStreamingHandler::new();
let handler = ResponderMessageHandler::new(
    storage.clone(),
    streaming.clone(),
    storage.push_notifier(),
    Shout,
);

let card = SimpleAgentInfo::new("shout".to_string(), "http://127.0.0.1:8080".to_string())
    .with_description("Repeats what you say, louder".to_string())
    .with_streaming();
let processor = ConnectRpcAdapter::new(handler, storage.clone(), storage, card.clone())
    .with_streaming_handler(streaming);

HttpServer::new(processor, card, "127.0.0.1:8080".to_string())
    .start()
    .await?;

use a2a_rs::{HttpClient, Message, Transport};
use a2a_rs::domain::SendCompletion;

let client = HttpClient::new("http://127.0.0.1:8080".to_string());
let message = Message::user_text("hello, agent".to_string(), uuid::Uuid::new_v4().to_string());

// `WhenSettled` is the A2A default: the server answers once the task has
// finished, so the reply is already in `task.history`.
let task = client
    .send_task_message(None, &message, None, None, SendCompletion::WhenSettled)
    .await?;

println!("task {} is {:?}", task.id, task.status.state);
// task 7725e89c-… is TASK_STATE_COMPLETED

cargo install a2acli

export A2A_URL=http://127.0.0.1:8080
a2acli card                           # what can this agent do?
a2acli send "hello, agent"            # send, and wait for the reply
a2acli list --state input-required    # tasks waiting on you
a2acli stream t1 --resilient          # follow a task, reconnecting on drop

[dependencies]
a2a-rs = { version = "0.10", features = ["http-server", "http-client"] }

# Or pick other features:
#   jsonrpc-server / jsonrpc-client   the spec's JSON-RPC 2.0 and HTTP+JSON bindings
#   auth                              JWT, OAuth2, OpenID Connect
#   sqlite / postgres                 SQLx task storage
#   full                              all of the above