Struct Runner 

pub struct Runner { /* private fields */ }

Orchestrates agent execution across Gemini Live sessions.

Handles the full lifecycle: connect → run → transfer → reconnect → repeat. Transfer is complex in Gemini Live because tools are fixed at setup — changing agents means changing sessions.

Example

let runner = Runner::new(root_agent);

runner.run(|agent| async move {
    let config = SessionConfig::new(&api_key)
        .model(GeminiModel::GeminiLive2_5FlashNativeAudio);
    // Add agent's tools to config
    let session = connect(config, TransportConfig::default()).await?;
    Ok(AgentSession::new(session))
}).await?;

Implementations

impl Runner

pub fn new(root_agent: impl Agent + 'static) -> Self

Create a new Runner with a root agent.

Automatically registers the root agent and all sub-agents recursively.

pub fn from_arc(root_agent: Arc<dyn Agent>) -> Self

Create a Runner from an already-Arc’d agent.

pub fn with_middleware(self, mw: impl Middleware + 'static) -> Self

Add middleware to the runner (applied to all agent invocations).

pub fn with_plugin(self, plugin: impl Plugin + 'static) -> Self

Add a plugin to the runner.

pub fn with_state(self, state: State) -> Self

Set initial state (available to all agents).

pub fn register(&mut self, agent: Arc<dyn Agent>)

Manually register an additional agent (useful for cross-tree transfers).

pub fn registry(&self) -> &AgentRegistry

Access the agent registry.

pub fn root_agent(&self) -> &dyn Agent

Access the root agent.

pub async fn run<F, Fut>(&self, connect_fn: F) -> Result<(), AgentError>

where F: Fn(Arc<dyn Agent>) -> Fut + Send + Sync, Fut: Future<Output = Result<AgentSession, AgentError>> + Send,

Run the agent lifecycle. Handles transfers automatically.

connect_fn is a factory that creates a new AgentSession for a given agent. This allows the Runner to reconnect with different configs on agent transfer (different tools/instructions → different Gemini Live session).

The Runner will:

1. Call connect_fn with the current agent
2. Run agent.run_live() on the resulting session
3. If TransferRequested is returned, resolve the target agent, disconnect, preserve state, and loop back to step 1
4. If the agent completes normally, return Ok(())