Module prelude 

The kernel prelude — the names a typical application touches.

Deliberately a kernel, not an everything-glob. Anything not here lives in a focused submodule and is one import away:

Need	Import
Full Live control plane (persistence, repair, steering, transcripts, contracts)	use gemini_adk_fluent_rs::live::*;
Text-agent runtime details	use gemini_adk_fluent_rs::text::*;
Toolsets, confirmation, frames	use gemini_adk_fluent_rs::tools::*;
State prefixes / SlotEvidence	use gemini_adk_fluent_rs::state::*;
Full flow vocabulary (CompiledFlow, StepAction, Violation, …)	use gemini_adk_fluent_rs::flow::*;
Agent trait + operator/pattern internals	use gemini_adk_fluent_rs::agents::*;
Conversation compiler internals (ResolverRegistry, StageSpec, OverlaySpec, …)	use gemini_adk_fluent_rs::conversation::*; (Conversation, ConversationSpec, CompiledConversation are in the prelude)
Serializable scenarios (Scenario, SimStep)	use gemini_adk_fluent_rs::simulation::*; (Sim is in the prelude)
A2A, motifs, policy, testing, orchestration, credentials, run_config	the same-named module, e.g. use gemini_adk_fluent_rs::policy::*;
Raw L0 wire types	use gemini_adk_fluent_rs::wire::*;

Re-exports

pub use crate::voice::Talk;

pub use crate::compose::A;

pub use crate::compose::C;

pub use crate::compose::Ctx;

pub use crate::compose::E;

pub use crate::compose::G;

pub use crate::compose::M;

pub use crate::compose::P;

pub use crate::compose::S;

pub use crate::compose::T;

pub use crate::live::Live;

pub use crate::testing::AgentHarness;

pub use crate::testing::ContractViolation;

pub use crate::testing::DataFlowEdge;

pub use crate::testing::LiveViolation;

pub use crate::testing::check_contracts;

pub use crate::testing::check_live;

pub use crate::testing::diagnose;

pub use crate::testing::infer_data_flow;

pub use crate::conversation::CompiledConversation;

pub use crate::conversation::Conversation;

pub use crate::conversation::ConversationSpec;

pub use crate::simulation::Sim;

pub use crate::builder::*;

pub use crate::operators::*;

pub use crate::patterns::*;

Modules

tool

Tool dispatch — regular, streaming, and input-streaming tools.

tool_media

Tool media returns — the ADK pattern where a function response carries images or other media to the model alongside its JSON payload, so vision tools (screenshots, chart renderers, document croppers) feed the model something it can actually look at.

Structs

AudioTranscriptionConfig

Audio transcription settings, for the user’s audio (inputAudioTranscription) or the model’s (outputAudioTranscription).

AutomaticActivityDetection

Automatic activity detection (VAD) settings.

AvatarConfig

Live Avatar video output (Gemini 3.8 Live): a prebuilt avatar by name, or a custom one generated from a reference image.

Blob

A blob of inline data (audio, image, etc.) sent to or received from Gemini.

CallbackContext

Rich context for callbacks — provides access to state, artifacts, memory, and event actions for mutation.

Chat

A conversation with an agent: every send carries the turns before it, and the conversation keeps its own State.

ConfigError

A build-time configuration error: one or more problems found while validating user-supplied configuration (a Flow, a PhaseMachine, a ComputedRegistry, …).

Content

A content message containing a role and a sequence of parts.

DispatchTextAgent

Fire-and-forget background task launcher with global task budget.

EventCallbacks

Typed callback registry for Live session events.

Extract

A declarative extraction record: typed fields filled by recognizers and/or async resolvers.

FallbackTextAgent

Tries each child agent in sequence. Returns the first successful result. If all fail, returns the last error.

Flow

A governed conversation/tool DAG.

FlowMonitor

Observes the session trace, maintains the Marking, answers tool admissibility, and projects active postures.

FnTextAgent

Zero-cost state transform agent — executes a closure, no LLM call.

FsPersistence

File-system persistence (good for development and single-server deployments).

FunctionCall

A function call request from the model.

FunctionDeclaration

Schema for a single function that the model can call.

FunctionResponse

A function call response sent back to the model.

GeminiLlm

Concrete Gemini LLM implementation using gemini-live Client.

GeminiLlmParams

Parameters for constructing a GeminiLlm.

GenerationConfig

Generation config sent in the setup message.

JoinTextAgent

Waits for dispatched background tasks and collects their results.

LiveHandle

Handle for interacting with a running Live session.

LlmExtractor

LLM-backed turn extractor that sends transcript windows to an OOB LLM with a structured extraction prompt.

LlmTextAgent

Core text agent — calls BaseLlm::generate(), dispatches tools, loops until the model produces a final text response.

LoopTextAgent

Runs a text agent repeatedly until max iterations or a state predicate.

MapOverTextAgent

Iterates a single agent over each item in a state list. Reads state[list_key], runs agent per item (setting state[item_key]), collects results into state[output_key].

MemoryPersistence

In-memory persistence (good for tests).

ModelId

A Gemini model identifier, exactly as the API accepts it.

ParallelTextAgent

Runs text agents concurrently. All branches share state. Results are collected and joined with newlines.

RaceTextAgent

Runs agents concurrently, returns the first to complete. Cancels the rest.

RepairConfig

Configuration for the conversation repair system.

RepairPolicy

A step’s repair policy for the weird paths (silence, no-match, the user stalling). The stack sets repair:{step}:reprompt once the step has been active reprompt_after turns without completing, and repair:{step}:escalate after escalate_after. When escalate_to is set, the authoring layer lowers an extra edge gated on the escalate signal — a deterministic “give up and hand off”.

RouteRule

A routing rule: predicate over state → target agent.

RouteTextAgent

State-driven deterministic branching — evaluates predicates in order, dispatches to the first matching agent. Falls back to default if none match.

RunRequest

What to run: the new user turn, the conversation before it, and optionally the JSON shape the reply must take.

RunResult

The outcome of a run: the final text, and what it took to get there.

SafetySetting

Per-category safety configuration for content generation.

SequentialTextAgent

Runs text agents sequentially. Each agent sees state mutations from previous agents. The final agent’s output is the pipeline’s output.

SessionConfig

Complete session configuration — the builder entrypoint.

SimpleTool

Simple function tool that wraps an async closure.

SoftTurnDetector

Detects proactive silence — user stopped speaking but model didn’t respond.

SpeechConfig

Speech configuration for audio output.

State

A concurrent, type-safe state container that agents read from and write to.

StateKey

A compile-time typed state key that eliminates typo bugs and type mismatches.

TapTextAgent

Read-only observation agent. Calls a function with the state but cannot mutate it. Returns empty string. No LLM call.

TaskRegistry

Shared registry for dispatched background tasks.

TemplateInstruction

A full template-engine instruction (feature templates) — minijinja (Jinja2 syntax: conditionals, loops, filters) over the session state, mirroring ADK’s use_jinja2 instructions. The whole state is exposed as state (subscript prefixed keys: {{ state["session:turn_count"] }}), and every key that is a bare identifier is also available at top level ({{ name }}). Falls back to the empty string for missing values under Jinja’s default undefined semantics.

ThinkingConfig

Configuration for model thinking/reasoning (Gemini 2.5+).

TimeoutTextAgent

Wraps an agent with a time limit. Returns AgentError::Timeout if exceeded.

Tool

A tool declaration sent in the setup message. Each Tool object can contain one of: function declarations, urlContext, googleSearch, codeExecution, or googleSearchRetrieval.

ToolContext

The session a tool call runs in.

ToolDispatcher

Routes function calls to the right tool implementation.

ToolPolicy

Optional per-tool execution policy.

TranscriptBuffer

Accumulates input/output transcripts and segments them by turn boundaries.

TranscriptTurn

A single completed conversation turn with accumulated transcripts.

TypedTool

Type-safe function tool with auto-generated JSON Schema.

UsageMetadata

Usage metadata returned by the server on messages.

VoiceTiming

Voice pacing for one stage. Every field is optional; an unset field leaves the session’s own behaviour alone.

Enums

ActivityHandling

Controls how incoming audio interacts with model output.

AgentError

Errors that can occur during agent execution.

ApiEndpoint

API endpoint selector — Google AI (direct), Google AI with OAuth token, or Vertex AI.

AudioFormat

Audio encoding formats supported by the Gemini Live API.

ContextDelivery

When to deliver model-role context turns to the wire.

Enforcement

How a FlowMonitor treats off-path activity — enforcement vs observation.

ExtractionTrigger

Controls WHEN an extractor runs.

FinishReason

Why the model stopped generating.

FunctionCallingBehavior

Whether tool calls block model output or run concurrently.

FunctionResponseScheduling

Scheduling mode for non-blocking function responses.

Guard

A boolean predicate over (state, marking) — the only predicate type.

HarmBlockThreshold

Blocking threshold for safety settings.

HarmCategory

Categories of potential harm in model output.

LlmError

Errors from LLM operations.

Modality

Output modalities the model can produce.

Part

A single part of a Content message. Parts are polymorphic — discriminated by field presence, not a type tag.

PersistenceError

Error returned by a SessionPersistence backend.

Role

Role in a conversation.

RunEvent

Something that happened during a streamed run; see TextAgent::run_stream.

Sensitivity

Voice activity detection sensitivity level.

ServerMessage

Unified server message enum — parsed from incoming WebSocket text frames.

SessionEvent

Events emitted by the session, consumed by application code.

SteeringMode

How the phase machine steers the model’s behavior.

ToolError

Errors that can occur during tool execution.

TurnCoverage

Controls which input counts toward a user’s conversation turn.

Verdict

The conformance status of a step.

Voice

Available voice presets for Gemini Live audio output.

Traits

Agent

The fundamental agent trait. Everything that can process a live session implements this — LLM agents, function agents, pipelines, routers.

BaseLlm

Trait for LLM providers — decouples agents from specific models.

Frame

A typed conversation frame. Implement via #[derive(Frame)].

InstructionProvider

A dynamic instruction source — the ADK “instruction provider” pattern: instead of a string fixed at build time, the instruction is produced from live session state on every model request (persona switching, risk-driven guardrails, multi-tenant instructions without rebuilding the agent). Any Fn(&State) -> String closure is a provider.

SessionPersistence

Trait for persisting session state across process restarts.

StreamExt

An extension trait for Streams that provides a variety of convenient combinator functions.

TextAgent

A text-based agent that runs via BaseLlm::generate() (request/response).

ToolFunction

A regular tool — called once, returns a result.

TurnExtractor

Trait for between-turn extraction from transcript windows.

Type Aliases

AgentResult

Convenience alias for fallible agent-runtime operations.

Attribute Macros

tool

Turn a documented async fn into a registrable Gemini tool.

Derive Macros

Extract

Derive an Extract record builder from a struct’s fields.

Frame

Derive a Frame impl from a struct’s #[slot(..)] fields.