Architectural Innovations

Bidirectional Flow Diagram

Core Architecture Components

• 1. RelayActor: Coordinator running the main event loop. Bridges LiveKit's real-time WebRTC track callback/channels with A2A client network events.
• 2. TurnManager: Atomic turn counter ensuring synchronization. Generates a new turn upon user interruption and discards stale incoming frames.
• 3. AudioJitterBuffer: Ring buffer smoothing playback against clock-drift and network jitter, outputting comfort noise on underflow and dropping old frames on overflow.
• 4. EnergyVad: Voice Activity Detector measuring root-mean-square (RMS) energy with a configurable hangover window to prevent word truncation.

Core Types & Traits

The system exposes the driver actor RelayActor<C, V> and a pluggable client interface via the A2aClient trait.

[Trait] A2aClient

pub trait A2aClient: Send + Sync + 'static {
    /// Send a buffer of PCM samples to the remote agent for the given turn.
    fn send_audio(&self, turn_id: u64, samples: &[i16]) -> impl Future
> + Send;

    /// Cancel the specified turn (due to user interruption).
    fn cancel_turn(&self, turn_id: u64) -> impl Future
> + Send;

    /// Request the speaking floor from the remote agent.
    fn request_floor(&self) -> impl Future
> + Send;

    /// Release the speaking floor.
    fn release_floor(&self) -> impl Future
> + Send;

    /// Subscribe to incoming frames from the agent.
    fn subscribe_frames(&self) -> mpsc::UnboundedReceiver;
}

Spawning a Relay with the Official Client

Initialize a LiveKit WebRTC connection and run the relay utilizing the OfficialA2aClient:

use livekit_a2a_relay::{RelayActor, OfficialA2aClient, EnergyVad};
use livekit::prelude::*;
use std::sync::Arc;
use tokio::sync::{mpsc, watch};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let url = "http://localhost:7880";
    let token = "YOUR_LIVEKIT_TOKEN";
    let (room, mut room_events) = Room::connect(url, token, RoomOptions::default()).await?;
    let room = Arc::new(room);

    // Setup NativeAudioSource for sending playback audio to LiveKit
    let sample_rate = 16000;
    let num_channels = 1;
    let audio_source = NativeAudioSource::new(AudioSourceOptions::default(), sample_rate, num_channels);
    let track = LocalAudioTrack::create_audio_track("agent-voice", audio_source.clone().into());
    room.local_participant().publish_track(track.clone(), TrackPublishOptions::default()).await?;

    let a2a_client = Arc::new(OfficialA2aClient::from_agent_url("https://my-a2a-agent.example.com").await?);
    let vad = EnergyVad::new(0.015, 250, sample_rate); // threshold: 0.015, hangover: 250ms

    let relay = RelayActor::new(room.clone(), a2a_client, track, audio_source, vad, sample_rate, num_channels);
    let (shutdown_tx, shutdown_rx) = watch::channel(false);
    let (audio_in_tx, audio_in_rx) = mpsc::unbounded_channel();

    tokio::spawn(relay.run(shutdown_rx, audio_in_rx));
    Ok(())
}

Testing & Local Execution

# Run local integration tests with the a2a-client feature flag
BINDGEN_EXTRA_CLANG_ARGS="-I/usr/lib/llvm-20/lib/clang/20/include" \
PATH="/home/jayaprakash/Android/Sdk/cmake/3.22.1/bin:$PATH" \
cargo test --features a2a-client