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 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 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 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.

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 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.