Struct LiveSessionBuilder 

pub struct LiveSessionBuilder { /* private fields */ }

Builder for a callback-driven Live session.

Combines SessionConfig, EventCallbacks, tool dispatching, extractors, computed state, phase machines, watchers, and temporal patterns into a single connection setup. Call connect() to establish the WebSocket connection and start the three-lane event processor.

For ergonomic usage, prefer the L2 Live builder from gemini-adk-fluent-rs which wraps this with a fluent API.

Implementations

impl LiveSessionBuilder

pub fn new(config: SessionConfig) -> Self

Create a new builder with the given session config.

pub fn tasks(self, tasks: TaskRuntime) -> Self

Install a catalog of independently owned tasks in this voice session.

Task commands and completions run on the control lane. A task session cannot also install session-wide governance or state-changing pipelines.

pub fn redaction(self, redactor: TranscriptRedactor) -> Self

Install transcript redaction — see redaction::TranscriptRedactor.

Applied at the event router, before callbacks, the transcript buffer, extraction, or persistence see the text. An inactive redactor (no rules enabled) is dropped rather than installed.

pub fn clock(self, clock: SharedClock) -> Self

Read the time from clock instead of the system clock.

Installed on the session State (see State::set_clock), so temporal patterns, phase durations, resolver cache expiry, the session: timing signals and journal timestamps all follow it. Pass a ManualClock to make timing decisions reproducible in tests; replay installs one driven by the recording.

pub fn middleware(self, layer: Arc<dyn Middleware>) -> Self

Add a middleware layer.

Layers run around tool dispatch in the control lane: before_tool (a returned error vetoes the call), after_tool, and on_tool_error. Multiple calls accumulate in order.

pub fn flow_monitor(self, monitor: FlowMonitor) -> Self

Attach a governed-flow monitor (built from a Flow + Mode). The monitor becomes the main layer of a FlowStack with no digressions.

pub fn flow_stack(self, stack: FlowStack) -> Self

Attach a governed-flow stack: the main flow plus its digressions and repair policies. This is the one governance object the control plane drives; flow_monitor is the no-digression special case.

pub fn decisions(self, decisions: Arc<Decisions>) -> Self

The questions a decision model answers about the conversation, for guards that use the decided atom (see crate::flow::decided).

At each decision point (the caller’s turn ends, or the model calls a tool) the runtime asks, in one request, the questions the flow can act on then, plus the standing ones, against the rolling conversation and the active stages’ grounding lines. A tool call is admitted after its questions are answered for the caller’s latest words, and a digression whose trigger they satisfy opens before the call is admitted.

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

Provide a pre-created State to use for this session.

If not set, a new State is created at connect time. Use this when the State needs to be shared with tools or other components before the session connects.

pub fn greeting(self, prompt: impl Into<String>) -> Self

Set a greeting prompt sent on connect to trigger the model to speak first.

pub fn code_mode(self, code: CodeMode) -> Self

Give the model a code tool: it runs a short Python program whose functions are the session’s tools, each call down the same governed path as a direct call. See code_mode.

pub fn dispatcher(self, dispatcher: ToolDispatcher) -> Self

Set the tool dispatcher for auto-dispatch of tool calls.

pub fn callbacks(self, callbacks: EventCallbacks) -> Self

Set the event callbacks.

pub fn extractor(self, extractor: Arc<dyn TurnExtractor>) -> Self

Add a turn extractor that runs between turns.

pub fn computed(self, registry: ComputedRegistry) -> Self

Set the computed variable registry for derived state.

pub fn phase_machine(self, machine: PhaseMachine) -> Self

Set the phase machine for declarative conversation phase management.

pub fn watchers(self, registry: WatcherRegistry) -> Self

Set the watcher registry for state change watchers.

pub fn temporal(self, registry: TemporalRegistry) -> Self

Set the temporal pattern registry.

pub fn tool_execution_mode( self, tool_name: impl Into<String>, mode: ToolExecutionMode, ) -> Self

Set the execution mode for a named tool.

Tools default to ToolExecutionMode::Standard. Set to ToolExecutionMode::Background for zero-dead-air execution.

pub fn soft_turn_timeout(self, timeout: Duration) -> Self

Enable soft turn detection for proactive silence awareness.

When proactiveAudio is enabled, the model may choose not to respond. This sets a timeout after VAD end — if the model stays silent, a lightweight “soft turn” fires to keep state updated without forcing the model to speak.

pub fn steering_mode(self, mode: SteeringMode) -> Self

Set the steering mode for how the phase machine delivers instructions.

A task session (see tasks) on a model that accepts contextUpdate declares only the foreground skill’s tools unless this sets a mode other than SteeringMode::ContextUpdate.

pub fn context_delivery(self, mode: ContextDelivery) -> Self

Set the context delivery timing.

• Immediate (default): send batched context during TurnComplete.
• Deferred: queue context and flush with next user send.

pub fn delivery(self, delivery: DeliveryConfig) -> Self

Set the fast-lane delivery (backpressure) policy per event class.

Defaults to all-Lossless, which preserves the historical send().await routing behavior. Opt classes into LossyDropNewest to keep the router from stalling when a fast-lane consumer falls behind.

pub fn repair(self, config: RepairConfig) -> Self

Enable the conversation repair protocol.

Tracks need fulfillment per phase and nudges the model when the conversation stalls on gathering required information.

pub fn persistence(self, backend: Arc<dyn SessionPersistence>) -> Self

Set a session persistence backend for surviving process restarts.

pub fn session_id(self, id: impl Into<String>) -> Self

Set the session ID for persistence.

pub fn tool_advisory(self, enabled: bool) -> Self

Enable or disable tool availability advisory on phase transitions.

pub fn telemetry_interval(self, interval: Duration) -> Self

Set the periodic telemetry emission interval.

When set, the processor periodically emits LiveEvent::Telemetry and LiveEvent::TurnMetrics to the event stream.

pub fn event_capacity(self, capacity: usize) -> Self

Set how many LiveEvents a subscriber can fall behind before it starts skipping the oldest ones.

The buffer behind LiveHandle::events is allocated in full when the session starts, at roughly 170 bytes per slot, whether or not anyone subscribes. The default, DEFAULT_EVENT_CAPACITY, is enough for a subscriber that hands each event on without waiting. Raise it when a subscriber does slow work inline, such as pacing audio to a device from its receive loop; a lagging subscriber gets RecvError::Lagged and skips events. Values below 1 are raised to 1.

pub async fn connect(self) -> Result<LiveHandle, AgentError>

Connect to Gemini and start the three-lane event processor.

This is a thin orchestrator over three explicit, behavior-preserving stages:

1. into_plan — pure derivation/validation of the resolved startup configuration (SessionPlan); no I/O, no spawning.
2. Connect the L0 transport using the plan’s resolved SessionConfig.
3. build_runtime — assemble the runtime wiring (channels, shared state, dispatcher, control plane) from the plan + connected session.
4. spawn_lanes — spawn the telemetry/event/tool lanes and return the assembled LiveHandle.

pub async fn connect_with_transport<T: Transport>( self, transport: T, ) -> Result<LiveHandle, AgentError>

connect over transport instead of a WebSocket to Gemini: the whole runtime (phases, tools, extractors, watchers, flow governance) runs as it would live, against whatever the transport answers.

Use it to test a session without a network or a credential, over a ReplayTransport scripted with server frames. The transport is not reconnected if it closes.