Crate gemini_live 

gemini-live

High-performance, idiomatic Rust client for the Gemini Multimodal Live API.

Designed for real-time audio/video streaming where every allocation counts. See audio::AudioEncoder for the zero-allocation hot path, docs/design.md for performance goals, and docs/roadmap.md for known gaps and planned work.

Architecture

The crate is organised in layers — each builds on the one below:

Layer	Module	Responsibility
Session	session	Connection lifecycle, reconnection, typed send/receive
Transport	transport	WebSocket connection, TLS, frame I/O
Codec	codec	JSON ↔ Rust; ServerMessage → ServerEvent decomposition
Audio	audio	PCM encoding utilities and format constants
Types	types	Strongly-typed wire-format structs
Errors	error	Layered error enums

Quick start

use gemini_live::session::{Session, SessionConfig, ReconnectPolicy};
use gemini_live::transport::{Auth, TransportConfig};
use gemini_live::types::*;

let mut session = Session::connect(SessionConfig {
    transport: TransportConfig {
        auth: Auth::ApiKey(std::env::var("GEMINI_API_KEY")?),
        ..Default::default()
    },
    setup: SetupConfig {
        model: "models/gemini-3.1-flash-live-preview".into(),
        generation_config: Some(GenerationConfig {
            response_modalities: Some(vec![Modality::Text]),
            ..Default::default()
        }),
        ..Default::default()
    },
    reconnect: ReconnectPolicy::default(),
}).await?;

session.send_text("Hello!").await?;

while let Some(event) = session.next_event().await {
    match event {
        ServerEvent::ModelText(text) => print!("{text}"),
        ServerEvent::TurnComplete => println!("\n--- turn done ---"),
        _ => {}
    }
}

For Vertex AI, switch the transport endpoint and auth mode:

use gemini_live::session::{ReconnectPolicy, Session, SessionConfig};
use gemini_live::transport::{Auth, Endpoint, TransportConfig};
use gemini_live::types::*;

let mut session = Session::connect(SessionConfig {
    transport: TransportConfig {
        endpoint: Endpoint::VertexAi {
            location: "us-central1".into(),
        },
        auth: Auth::BearerToken(std::env::var("VERTEX_AI_ACCESS_TOKEN")?),
        ..Default::default()
    },
    setup: SetupConfig {
        model: std::env::var("VERTEX_MODEL")?,
        generation_config: Some(GenerationConfig {
            response_modalities: Some(vec![Modality::Text]),
            ..Default::default()
        }),
        ..Default::default()
    },
    reconnect: ReconnectPolicy::default(),
})
.await?;

Enable the optional vertex-auth crate feature if you want the library to obtain Vertex bearer tokens from Google Cloud Application Default Credentials instead of passing a static token string.

Re-exports

pub use session::ReconnectPolicy;

pub use session::Session;

pub use session::SessionConfig;

pub use session::SessionStatus;

pub use transport::Auth;

pub use transport::BearerTokenProvider;

pub use transport::Connection;

pub use transport::Endpoint;

pub use transport::RawFrame;

pub use transport::TransportConfig;

pub use error::*;

pub use types::*;

Modules

audio

Audio encoding utilities for the Gemini Live API.

codec

JSON ↔ Rust codec and semantic event decomposition.

error

Error types for each architectural layer.

session

Session layer — the primary interface for the Gemini Live API.

transport

WebSocket transport layer.

types

Strongly-typed representations of the Gemini Live wire protocol.