Enum SteeringMode 

pub enum SteeringMode {
    InstructionUpdate,
    ContextInjection,
    Hybrid,
    ContextUpdate,
}

How the phase machine steers the model’s behavior.

Controls two things:

1. Phase instruction delivery — whether the phase instruction is sent as a system instruction update (update_instruction) or as a model-role context turn (send_client_content).
2. Per-turn modifier delivery — whether with_state, when, and with_context modifiers are baked into the system instruction or injected as model-role context turns.

Choosing a mode

Mode	System instruction	Modifiers	Best for
InstructionUpdate	Replaced on every phase transition	Baked into instruction	Agents with radically different personas per phase
ContextInjection	Set once at connect, never touched	Model-role context turns	Multi-phase apps with stable persona (recommended)
Hybrid	Replaced on phase transition	Model-role context turns	Persona shifts + lightweight per-turn context
ContextUpdate	Base + phase instruction, replaced on phase transition; tools re-declared per phase and step	Model-role context turns	Gemini 3.8 Live sessions whose phases or flow steps use different tools

Example

use gemini_adk_fluent_rs::prelude::*;

// Recommended: base instruction at connect, phase context via injection
let handle = Live::builder()
    .instruction("You are a helpful restaurant reservation assistant.")
    .steering_mode(SteeringMode::ContextInjection)
    .phase("greeting")
        .instruction("Welcome the guest and ask how you can help.")
        .done()
    .phase("booking")
        .instruction("Help the guest find an available time slot.")
        .done()
    .initial_phase("greeting")
    .connect_google_ai(api_key)
    .await?;

Variants

InstructionUpdate

Replace system instruction on phase transition.

The model re-processes its full context on every phase change. Gives the clearest persona shift but causes a latency spike as the model ingests the new instruction.

Per-turn modifiers (with_state, when, with_context) are baked into the system instruction text.

ContextInjection

Inject all steering via send_client_content (model-role turns).

The system instruction set at connect time is never updated. Phase instructions and per-turn modifiers are delivered as model-role context turns, working with the model’s conversational intelligence rather than overriding it.

Lighter weight, lower latency, avoids instruction re-processing. Best for multi-phase apps where the base persona is stable.

Hybrid

Hybrid: instruction update on phase transition + context injection per turn.

Phase transitions trigger a system instruction replacement (like InstructionUpdate), but per-turn modifiers are delivered as model-role context turns (like ContextInjection).

Use when phases represent genuinely different personas but you also want lightweight per-turn steering within each phase.

ContextUpdate

Replace the declared tools and the system instruction with a contextUpdate message at each phase transition and flow-step change (Gemini 3.8 Live).

The model is offered only the tools the current phase lists (Phase::tools_enabled) and an enforcing flow admits, from the setup message on. Under the other modes those lists are enforced by refusing calls, while the model is offered every tool. When a step changes on a tool result, the new declarations are sent before that tool response.

The system instruction becomes the connect-time instruction followed by the current phase’s instruction: unlike an instruction update, a contextUpdate replaces the instruction outright, so the base is kept explicitly. An instruction_template still replaces the whole instruction. Per-turn modifiers are delivered as model-role context turns, as in Hybrid: each contextUpdate invalidates the server’s prefix cache, so it is sent only when the instruction or the tool set changes.

On a model without contextUpdate (Gemini 2.5 Live), the session logs a warning at connect and steers as Hybrid.

Trait Implementations

impl Clone for SteeringMode

fn clone(&self) -> SteeringMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SteeringMode

impl Debug for SteeringMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SteeringMode

fn default() -> SteeringMode

Returns the “default value” for a type.

impl Eq for SteeringMode

impl PartialEq for SteeringMode

fn eq(&self, other: &SteeringMode) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SteeringMode