Crate lc_a2a 

A2A (Agent-to-Agent) protocol support.

This module implements the A2A protocol for inter-agent communication. It enables LangChain Rust agents to discover, invoke, and communicate with other agents over HTTP using a JSON-RPC style protocol.

Architecture

• protocol: Core data types (AgentCard, A2ATask, A2ARequest, etc.)
• server: A2AServer - handler functions to expose an agent via A2A
• client: A2AClient - HTTP client to connect to remote A2A agents
• rate_limiter: RateLimiter - concurrency + per-minute request limits

Quick Start

Server (expose your agent)

use lc_a2a::{A2AServer, AgentCard};
use lc_chains::LLMChain;
use std::sync::Arc;

let chain = Arc::new(LLMChain::new(llm, "You are a helpful assistant"));
let server = A2AServer::new(chain)
    .with_card(AgentCard::new("my-agent", "A helpful agent", "http://localhost:8080"));

// In your HTTP handler (axum, actix, warp, etc.):
// GET /.well-known/agent-card.json -> server.get_agent_card()
// POST / -> server.handle_a2a_request(body).await

Client (call a remote agent)

use lc_a2a::{A2AClient, A2AMessage};

let client = A2AClient::new("http://localhost:8080".to_string()).unwrap();
let card = client.get_agent_card().await?;
let task = client.send_task(A2AMessage::user("hello")).await?;

Re-exports

pub use agent_adapter::AgentExecutorChain;

pub use client::A2AClient;

pub use client::A2AClientBuilder;

pub use client::A2AError;

pub use discovery::AgentRegistry;

pub use discovery::RegistryClient;

pub use discovery::RegistryError;

pub use gateway::CallPolicy;

pub use gateway::DataContract;

pub use gateway::FederationGateway;

pub use gateway::GatewayError;

pub use protocol::metadata_keys;

pub use protocol::A2AErrorData;

pub use protocol::A2AMessage;

pub use protocol::A2ARequest;

pub use protocol::A2AResponse;

pub use protocol::A2ATask;

pub use protocol::A2ATaskDetails;

pub use protocol::A2ATaskResult;

pub use protocol::A2AWorkflow;

pub use protocol::AgentCard;

pub use protocol::AgentSkill;

pub use protocol::MessageEnvelope;

pub use protocol::TaskFilter;

pub use protocol::TaskPushNotification;

pub use protocol::TaskStatus;

pub use protocol::TraceContext;

pub use protocol::WorkflowStep;

pub use rate_limiter::RateLimitError;

pub use rate_limiter::RateLimiter;

pub use resilient::ResilienceConfig;

pub use resilient::ResilientA2AClient;

pub use router::SkillMapRouter;

pub use router::SkillRouter;

pub use scale::AgentTier;

pub use scale::BreakerState;

pub use scale::CircuitBreaker;

pub use scale::CircuitBreakerConfig;

pub use scale::DelegationGuard;

pub use scale::HierarchyPolicy;

pub use scale::ScaleError;

pub use scale::SkillEntry;

pub use scale::SkillIndex;

pub use scale::StickyRouter;

pub use scale::TaskGraph;

pub use scale::TaskSharder;

pub use security::AccessRequest;

pub use security::SandboxConfig;

pub use security::SecurityError;

pub use security::TrustConfig;

pub use security::TrustRegistry;

pub use security::TrustRole;

pub use security::TrustVerification;

pub use security::TrustedAgent;

pub use server::A2AServer;

pub use store::in_memory_store;

pub use store::InMemoryTaskStore;

pub use store::StoreError;

pub use store::StoredTask;

pub use store::TaskStore;

Modules

agent_adapter

P1-8: adapt a stateful AgentExecutor to the stateless BaseChain facade.

client

A2A Client - connects to remote A2A agents over HTTP.

discovery

P2-8: agent discovery.

gateway

P2-7: cross-organization federation gateway.

protocol

A2A (Agent-to-Agent) protocol types.

rate_limiter

Rate limiting for A2A requests.

resilient

P2-6: layered resilience for the A2A client.

router

Skill-based chain routing (P2-4).

scale

P2-9: scale to ~1000 agents.

security

P2-5: defense against malicious agents.

server

A2A Server - handler functions for the Agent-to-Agent protocol.

store

Task persistence abstraction (P1-1).