diff --git a/.changeset/huge-lizards-admire.md b/.changeset/huge-lizards-admire.md
new file mode 100644
index 000000000..977c6dd68
--- /dev/null
+++ b/.changeset/huge-lizards-admire.md
@@ -0,0 +1,8 @@
+---
+'@tanstack/ai-gemini': minor
+'@tanstack/ai-client': minor
+'@tanstack/ai-react': minor
+'@tanstack/ai': minor
+---
+
+Added Gemini Realtime Adapter
diff --git a/docs/media/realtime-chat.md b/docs/media/realtime-chat.md
index c800d57d6..8516f89c0 100644
--- a/docs/media/realtime-chat.md
+++ b/docs/media/realtime-chat.md
@@ -187,7 +187,7 @@ import { useRealtimeChat } from '@tanstack/ai-react'
 import { openaiRealtime } from '@tanstack/ai-openai'
 import { getToken } from './token'
 
-const { startListening, stopListening, vadMode, setVADMode } = useRealtimeChat({
+const { startListening, stopListening, updateSession } = useRealtimeChat({
   getToken,
   adapter: openaiRealtime(),
   vadMode: 'manual', // or 'server' or 'semantic'
@@ -202,10 +202,10 @@ With `manual` VAD mode, use push-to-talk style interactions:
 </button>
 ```
 
-You can switch VAD mode at runtime without reconnecting:
+You can switch VAD mode at runtime without reconnecting, via `updateSession`:
 
 ```typescript ignore
-setVADMode('semantic')
+updateSession({ vadMode: 'semantic' })
 ```
 
 For semantic VAD, configure eagerness to control how long the model waits before deciding you've finished speaking:
diff --git a/examples/ts-react-chat/src/lib/use-realtime.ts b/examples/ts-react-chat/src/lib/use-realtime.ts
index c32dd5031..44874ef0d 100644
--- a/examples/ts-react-chat/src/lib/use-realtime.ts
+++ b/examples/ts-react-chat/src/lib/use-realtime.ts
@@ -6,10 +6,11 @@ import {
   elevenlabsRealtime,
   elevenlabsRealtimeToken,
 } from '@tanstack/ai-elevenlabs'
+import { geminiRealtime, geminiRealtimeToken } from '@tanstack/ai-gemini'
 import { grokRealtime, grokRealtimeToken } from '@tanstack/ai-grok'
 import { realtimeClientTools } from '@/lib/realtime-tools'
 
-type Provider = 'openai' | 'elevenlabs' | 'grok'
+type Provider = 'openai' | 'elevenlabs' | 'gemini' | 'grok'
 
 const getRealtimeTokenFn = createServerFn({ method: 'POST' })
   .inputValidator((data: { provider: Provider; language?: string }) => {
@@ -25,6 +26,12 @@ const getRealtimeTokenFn = createServerFn({ method: 'POST' })
       })
     }
 
+    if (data.provider === 'gemini') {
+      return realtimeToken({
+        adapter: geminiRealtimeToken(),
+      })
+    }
+
     if (data.provider === 'elevenlabs') {
       return realtimeToken({
         adapter: elevenlabsRealtimeToken({
@@ -48,6 +55,8 @@ function adapterForProvider(provider: Provider) {
       return openaiRealtime()
     case 'elevenlabs':
       return elevenlabsRealtime()
+    case 'gemini':
+      return geminiRealtime()
     case 'grok':
       return grokRealtime()
   }
@@ -91,7 +100,9 @@ Keep your responses concise and conversational since this is a voice interface.
 When using tools, briefly explain what you're doing and then share the results naturally.
 If the user sends an image, describe what you see and answer any questions about it.
 Be friendly and engaging!`,
-    voice: voice ?? (provider === 'grok' ? 'eve' : 'alloy'),
+    voice:
+      voice ??
+      (provider === 'grok' ? 'eve' : provider === 'gemini' ? 'Puck' : 'alloy'),
     tools: realtimeClientTools,
     outputModalities,
     temperature,
diff --git a/examples/ts-react-chat/src/routes/realtime.tsx b/examples/ts-react-chat/src/routes/realtime.tsx
index 5f75fd3e7..d20ebe2fa 100644
--- a/examples/ts-react-chat/src/routes/realtime.tsx
+++ b/examples/ts-react-chat/src/routes/realtime.tsx
@@ -13,12 +13,13 @@ import {
 import { AudioSparkline } from '@/components/AudioSparkline'
 import { useRealtime } from '@/lib/use-realtime'
 
-type Provider = 'openai' | 'elevenlabs' | 'grok'
+type Provider = 'openai' | 'elevenlabs' | 'gemini' | 'grok'
 type OutputMode = 'audio+text' | 'text-only' | 'audio-only'
 
 const PROVIDER_OPTIONS: Array<{ value: Provider; label: string }> = [
   { value: 'openai', label: 'OpenAI Realtime' },
   { value: 'elevenlabs', label: 'ElevenLabs' },
+  { value: 'gemini', label: 'Google Gemini' },
   { value: 'grok', label: 'Grok Voice Agent' },
 ]
 
@@ -287,7 +288,9 @@ function RealtimePage() {
               )}
 
               {/* Output mode selector (OpenAI-compatible realtime) */}
-              {(provider === 'openai' || provider === 'grok') && (
+              {(provider === 'openai' ||
+                provider === 'gemini' ||
+                provider === 'grok') && (
                 <div>
                   <label className="text-sm text-gray-400 mb-1 block">
                     Output
@@ -310,7 +313,9 @@ function RealtimePage() {
               )}
 
               {/* Temperature slider */}
-              {(provider === 'openai' || provider === 'grok') && (
+              {(provider === 'openai' ||
+                provider === 'gemini' ||
+                provider === 'grok') && (
                 <div>
                   <label className="text-sm text-gray-400 mb-1 block">
                     Temp: {temperature.toFixed(1)}
@@ -366,7 +371,9 @@ function RealtimePage() {
         </div>
 
         {/* Tools indicator */}
-        {(provider === 'openai' || provider === 'grok') && (
+        {(provider === 'openai' ||
+          provider === 'gemini' ||
+          provider === 'grok') && (
           <div className="border-b border-orange-500/10 bg-gray-800/50 px-4 py-2">
             <div className="flex items-center gap-2 text-xs text-gray-400">
               <Wrench className="w-3 h-3" />
@@ -522,7 +529,9 @@ function RealtimePage() {
                 className="flex-1 rounded-lg border border-orange-500/20 bg-gray-800 px-4 py-2 text-sm text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-orange-500/50"
               />
               {/* Image upload button (OpenAI-compatible realtime) */}
-              {(provider === 'openai' || provider === 'grok') && (
+              {(provider === 'openai' ||
+                provider === 'gemini' ||
+                provider === 'grok') && (
                 <>
                   <input
                     ref={imageInputRef}
diff --git a/packages/ai-client/src/realtime-client.ts b/packages/ai-client/src/realtime-client.ts
index 1b1f5eaa4..780881874 100644
--- a/packages/ai-client/src/realtime-client.ts
+++ b/packages/ai-client/src/realtime-client.ts
@@ -4,6 +4,7 @@ import type {
   AudioVisualization,
   RealtimeMessage,
   RealtimeMode,
+  RealtimeSessionConfig,
   RealtimeStatus,
   RealtimeToken,
 } from '@tanstack/ai/client'
@@ -101,6 +102,7 @@ export class RealtimeClient {
         this.clientTools.size > 0
           ? Array.from(this.clientTools.values())
           : undefined
+
       this.connection = await this.options.adapter.connect(
         this.token,
         toolsList,
@@ -282,6 +284,38 @@ export class RealtimeClient {
     return this.connection?.getAudioVisualization() ?? null
   }
 
+  /**
+   * Update the session configuration.
+   * This applies changes to the active connection and persists them for future reconnections.
+   */
+  updateSession(config: Partial<RealtimeSessionConfig>): void {
+    // Persist type-compatible fields so future (re)connections use the updated
+    // config. `tools` is intentionally excluded: a session's tool configs are
+    // serialized descriptors, whereas `options.tools` holds executable client
+    // tools tracked separately via `clientTools`.
+    const o = this.options
+    if (config.instructions !== undefined) o.instructions = config.instructions
+    if (config.voice !== undefined) o.voice = config.voice
+    if (config.vadMode !== undefined) o.vadMode = config.vadMode
+    if (config.outputModalities !== undefined) {
+      o.outputModalities = config.outputModalities
+    }
+    if (config.temperature !== undefined) o.temperature = config.temperature
+    if (config.maxOutputTokens !== undefined) {
+      o.maxOutputTokens = config.maxOutputTokens
+    }
+    if (config.semanticEagerness !== undefined) {
+      o.semanticEagerness = config.semanticEagerness
+    }
+    if (config.providerOptions !== undefined) {
+      o.providerOptions = config.providerOptions
+    }
+
+    if (this.connection) {
+      this.applySessionConfig()
+    }
+  }
+
   // ============================================================================
   // State Subscription
   // ============================================================================
@@ -353,6 +387,7 @@ export class RealtimeClient {
     try {
       this.token = await this.options.getToken()
       this.scheduleTokenRefresh()
+      this.connection?.updateToken?.(this.token)
       // Note: Some providers may require reconnection with new token
       // This is handled by the adapter implementation
     } catch (error) {
@@ -487,6 +522,18 @@ export class RealtimeClient {
         this.options.onError?.(error)
       }),
     )
+
+    this.unsubscribers.push(
+      this.connection.on('go_away', ({ timeLeft }) => {
+        this.options.onGoAway?.(timeLeft)
+      }),
+    )
+
+    this.unsubscribers.push(
+      this.connection.on('usage', (usage) => {
+        this.options.onUsage?.(usage)
+      }),
+    )
   }
 
   private applySessionConfig(): void {
@@ -513,18 +560,22 @@ export class RealtimeClient {
       semanticEagerness
     if (!hasConfig) return
 
-    // `RealtimeToolConfig.inputSchema` is `Record<string, any>` (no
-    // `undefined` under `exactOptionalPropertyTypes`). Conditionally spread
-    // it so we don't pass `undefined` when the tool has no input schema.
+    // `RealtimeToolConfig.inputSchema`/`outputSchema` are `Record<string, any>`
+    // (no `undefined` under `exactOptionalPropertyTypes`). Conditionally spread
+    // each so we don't pass `undefined` when the tool has no such schema.
     const toolsConfig = tools
       ? Array.from(this.clientTools.values()).map((t) => {
           const inputSchema = t.inputSchema
             ? convertSchemaToJsonSchema(t.inputSchema)
             : undefined
+          const outputSchema = t.outputSchema
+            ? convertSchemaToJsonSchema(t.outputSchema)
+            : undefined
           return {
             name: t.name,
             description: t.description,
             ...(inputSchema ? { inputSchema } : {}),
+            ...(outputSchema ? { outputSchema } : {}),
           }
         })
       : undefined
diff --git a/packages/ai-client/src/realtime-types.ts b/packages/ai-client/src/realtime-types.ts
index 558817cd0..c6f2470a9 100644
--- a/packages/ai-client/src/realtime-types.ts
+++ b/packages/ai-client/src/realtime-types.ts
@@ -6,6 +6,7 @@ import type {
   RealtimeStatus,
   RealtimeToken,
 } from '@tanstack/ai/client'
+import type { UsageInfo } from '@tanstack/ai'
 
 // The realtime adapter contract lives in `@tanstack/ai` (the shared layer both
 // providers and this client depend on) so provider packages don't need to
@@ -82,6 +83,11 @@ export interface RealtimeClientOptions {
    */
   semanticEagerness?: 'low' | 'medium' | 'high'
 
+  /**
+   * Provider-specific options
+   */
+  providerOptions?: Record<string, unknown>
+
   // Callbacks
   onStatusChange?: (status: RealtimeStatus) => void
   onModeChange?: (mode: RealtimeMode) => void
@@ -90,6 +96,8 @@ export interface RealtimeClientOptions {
   onConnect?: () => void
   onDisconnect?: () => void
   onInterrupted?: () => void
+  onUsage?: (usage: UsageInfo) => void
+  onGoAway?: (timeLeft?: string) => void
 }
 
 // ============================================================================
diff --git a/packages/ai-gemini/src/index.ts b/packages/ai-gemini/src/index.ts
index 462de4067..fb7d29bba 100644
--- a/packages/ai-gemini/src/index.ts
+++ b/packages/ai-gemini/src/index.ts
@@ -125,3 +125,17 @@ export type {
 
 // Export provider usage types
 export type { GeminiProviderUsageDetails } from './usage'
+
+// ============================================================================
+// Realtime (Voice) Adapters
+// ============================================================================
+
+export { geminiRealtime, geminiRealtimeToken } from './realtime/index'
+
+export type {
+  GeminiRealtimeModel,
+  GeminiRealtimeOptions,
+  GeminiRealtimeProviderOptions,
+  GeminiRealtimeTokenOptions,
+  GeminiRealtimeVoice,
+} from './realtime/index'
diff --git a/packages/ai-gemini/src/realtime/adapter.ts b/packages/ai-gemini/src/realtime/adapter.ts
new file mode 100644
index 000000000..f3d47e2d5
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/adapter.ts
@@ -0,0 +1,311 @@
+import { createRealtimeEventEmitter } from '@tanstack/ai'
+import { AudioPlayer, AudioStreamer, base64ToArrayBuffer } from './utils'
+import { GeminiLiveClient } from './client'
+import type { LiveResponse } from './client'
+import type {
+  AnyClientTool,
+  AudioVisualization,
+  RealtimeAdapter,
+  RealtimeConnection,
+  RealtimeMessage,
+  RealtimeMode,
+  RealtimeToken,
+} from '@tanstack/ai'
+import type { GeminiRealtimeModel, GeminiRealtimeOptions } from './types'
+
+/**
+ * Creates a Gemini realtime adapter for client-side use.
+ *
+ * @param options - Optional configuration
+ * @returns A RealtimeAdapter for use with RealtimeClient
+ *
+ * @example
+ * ```typescript
+ * import { RealtimeClient } from '@tanstack/ai-client'
+ * import { geminiRealtime } from '@tanstack/ai-gemini'
+ *
+ * const client = new RealtimeClient({
+ *   getToken: () => fetch('/api/realtime-token').then(r => r.json()),
+ *   adapter: geminiRealtime(),
+ *   onGoAway: () => client.updateSession({ ... }) // Resume session with new config (available only for Gemini Live adapter)
+ * })
+ *
+ * ```
+ */
+export function geminiRealtime(
+  options: GeminiRealtimeOptions = {},
+): RealtimeAdapter {
+  return {
+    provider: 'gemini',
+
+    connect(
+      token: RealtimeToken,
+      clientTools?: ReadonlyArray<AnyClientTool>,
+    ): Promise<RealtimeConnection> {
+      return createWebSocketConnection(token, options.model, clientTools)
+    },
+  }
+}
+
+/**
+ * Creates a WebSocket connection to Gemini's realtime API
+ */
+async function createWebSocketConnection(
+  token: RealtimeToken,
+  model: GeminiRealtimeModel = 'gemini-3.1-flash-live-preview',
+  tools?: ReadonlyArray<AnyClientTool>,
+): Promise<RealtimeConnection> {
+  const { emit, on: realtimeEventEmitterOn } = createRealtimeEventEmitter()
+
+  // Current state
+  let currentMode: RealtimeMode = 'idle'
+  let currentMessageId: string | null = null
+  let messageIdCounter = 0
+
+  function generateMessageId(): string {
+    return `gemini-msg-${Date.now()}-${++messageIdCounter}`
+  }
+
+  const client = new GeminiLiveClient(token.token, model, tools)
+
+  let message: RealtimeMessage = {
+    id: '',
+    role: 'assistant',
+    timestamp: 0,
+    parts: [],
+  }
+
+  let pendingAssistantResponse = ''
+
+  client.onClose = () => {
+    emit('status_change', { status: 'idle' })
+    emit('mode_change', { mode: 'idle' })
+  }
+
+  client.onError = (error) => {
+    emit('error', { error })
+    emit('status_change', { status: 'error' })
+    emit('mode_change', { mode: 'idle' })
+  }
+
+  client.onReceiveResponse = (response: LiveResponse) => {
+    switch (response.type) {
+      case 'text':
+        message.parts.push({
+          type: 'text',
+          content: response.data,
+        })
+        break
+      case 'audio': {
+        // Decode once, then reuse for both the stored message part and playback.
+        const pcm = base64ToArrayBuffer(response.data.audioData)
+        message.parts.push({
+          type: 'audio',
+          transcript: response.data.transcript,
+          audioData: pcm,
+        })
+        if (currentMode !== 'speaking') {
+          currentMode = 'speaking'
+          emit('mode_change', { mode: 'speaking' })
+        }
+        audioPlayer.play(pcm).catch((error) => emit('error', { error }))
+        break
+      }
+      case 'go_away':
+        emit('go_away', { timeLeft: response.data.timeLeft })
+        break
+      case 'usage_metadata':
+        emit('usage', {
+          completionTokens: response.data.responseTokenCount ?? 0,
+          promptTokens: response.data.promptTokenCount ?? 0,
+          totalTokens: response.data.totalTokenCount ?? 0,
+        })
+        break
+      case 'input_transcription':
+        if (response.data.finished && currentMode !== 'thinking') {
+          currentMode = 'thinking'
+          emit('mode_change', { mode: 'thinking' })
+        }
+        emit('transcript', {
+          isFinal: response.data.finished,
+          transcript: response.data.text,
+          role: 'user',
+        })
+        break
+      case 'output_transcription':
+        pendingAssistantResponse += response.data.text
+        emit('transcript', {
+          isFinal: response.data.finished,
+          transcript: pendingAssistantResponse,
+          role: 'assistant',
+        })
+        break
+      case 'interrupted':
+        audioPlayer.interrupt()
+        currentMode = 'listening'
+        emit('mode_change', { mode: 'listening' })
+        emit('interrupted', { messageId: currentMessageId ?? undefined })
+        break
+      case 'tool_call':
+        for (const tool of response.data.functionCalls || []) {
+          if (tool.id && tool.name) {
+            emit('tool_call', {
+              toolCallId: tool.id,
+              input: tool.args,
+              toolName: tool.name,
+            })
+          }
+        }
+        break
+      case 'turn_complete':
+        currentMessageId = generateMessageId()
+        message.id = currentMessageId
+        message.timestamp = Date.now()
+        message.parts.push({
+          type: 'text',
+          content: pendingAssistantResponse,
+        })
+        emit('message_complete', { message })
+
+        pendingAssistantResponse = ''
+        message = {
+          id: '',
+          role: 'assistant',
+          timestamp: 0,
+          parts: [],
+        }
+        currentMode = 'listening'
+        emit('mode_change', { mode: 'listening' })
+        break
+      case 'setup_complete':
+        emit('status_change', { status: 'connected' })
+        break
+      case 'error':
+        emit('error', {
+          error: new Error(response.data),
+        })
+        break
+      case 'thought':
+      case 'session_resumption_update':
+        // Handled internally by GeminiLiveClient; not surfaced to the client.
+        break
+    }
+  }
+
+  await client.connect()
+
+  const audioStreamer = new AudioStreamer(client)
+  const audioPlayer = new AudioPlayer()
+  try {
+    await audioPlayer.init()
+    await audioStreamer.start()
+  } catch (error) {
+    // Tear down the socket + audio graph if mic/worklet setup fails (e.g. the
+    // user denied microphone access) rather than leaking an open connection.
+    audioStreamer.stop()
+    audioPlayer.destroy()
+    client.disconnect()
+    throw error
+  }
+
+  const connection: RealtimeConnection = {
+    async disconnect() {
+      audioStreamer.stop()
+      audioPlayer.destroy()
+      client.disconnect()
+      currentMode = 'idle'
+      emit('status_change', { status: 'idle' })
+    },
+
+    async startAudioCapture() {
+      // Audio capture is established during connection setup
+      audioStreamer.startAudioCapture()
+      currentMode = 'listening'
+      emit('mode_change', { mode: 'listening' })
+    },
+
+    stopAudioCapture() {
+      audioStreamer.stopAudioCapture()
+      currentMode = 'idle'
+      emit('mode_change', { mode: 'idle' })
+    },
+
+    sendText(text: string) {
+      client.sendTextMessage(text)
+      currentMode = 'thinking'
+      emit('mode_change', { mode: 'thinking' })
+    },
+
+    sendImage(imageData: string, mimeType: string) {
+      client.sendImageMessage(imageData, mimeType)
+      currentMode = 'thinking'
+      emit('mode_change', { mode: 'thinking' })
+    },
+
+    sendToolResult(callId: string, result: string) {
+      client.sendToolResponse([
+        {
+          id: callId,
+          response: {
+            result,
+          },
+        },
+      ])
+    },
+
+    updateSession(config) {
+      client.updateSession(config).catch((error) => emit('error', { error }))
+      emit('status_change', { status: 'reconnecting' })
+    },
+
+    updateToken(newToken) {
+      client.updateToken(newToken)
+      emit('status_change', { status: 'reconnecting' })
+    },
+
+    interrupt() {
+      audioPlayer.interrupt()
+      currentMode = 'listening'
+      emit('mode_change', { mode: 'listening' })
+      emit('interrupted', { messageId: currentMessageId ?? undefined })
+    },
+    on: realtimeEventEmitterOn,
+    getAudioVisualization(): AudioVisualization {
+      return {
+        get inputLevel() {
+          return audioStreamer.inputLevel
+        },
+
+        get outputLevel() {
+          return audioPlayer.outputLevel
+        },
+
+        getInputFrequencyData() {
+          return audioStreamer.inputFrequencyData
+        },
+
+        getOutputFrequencyData() {
+          return audioPlayer.outputFrequencyData
+        },
+
+        getInputTimeDomainData() {
+          return audioStreamer.inputTimeDomainData
+        },
+
+        getOutputTimeDomainData() {
+          return audioPlayer.outputTimeDomainData
+        },
+
+        get inputSampleRate() {
+          return audioStreamer.inputSampleRate
+        },
+
+        get outputSampleRate() {
+          return audioPlayer.outputSampleRate
+        },
+      }
+    },
+  }
+
+  return connection
+}
diff --git a/packages/ai-gemini/src/realtime/client.ts b/packages/ai-gemini/src/realtime/client.ts
new file mode 100644
index 000000000..49ae407fb
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/client.ts
@@ -0,0 +1,547 @@
+import { convertSchemaToJsonSchema } from '@tanstack/ai'
+import {
+  ActivityHandling,
+  EndSensitivity,
+  Modality,
+  StartSensitivity,
+  TurnCoverage,
+} from '@google/genai'
+import type {
+  ContextWindowCompressionConfig,
+  FunctionDeclaration,
+  FunctionResponse,
+  LiveClientMessage,
+  LiveServerGoAway,
+  LiveServerMessage,
+  LiveServerSessionResumptionUpdate,
+  LiveServerToolCall,
+  ThinkingConfig,
+  UsageMetadata,
+} from '@google/genai'
+import type {
+  AnyClientTool,
+  RealtimeSessionConfig,
+  RealtimeToken,
+  RealtimeToolConfig,
+} from '@tanstack/ai'
+import type {
+  GeminiRealtimeModel,
+  GeminiRealtimeProviderOptions,
+  GeminiRealtimeVoice,
+} from './types'
+
+/** Build a Gemini FunctionDeclaration from an isomorphic client tool (Zod). */
+function clientToolToDeclaration(tool: AnyClientTool): FunctionDeclaration {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parametersJsonSchema: convertSchemaToJsonSchema(tool.inputSchema),
+    responseJsonSchema: convertSchemaToJsonSchema(tool.outputSchema),
+  }
+}
+
+/** Build a Gemini FunctionDeclaration from an already-serialized tool config. */
+function toolConfigToDeclaration(
+  tool: RealtimeToolConfig,
+): FunctionDeclaration {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parametersJsonSchema: tool.inputSchema,
+    responseJsonSchema: tool.outputSchema,
+  }
+}
+
+interface LiveResponsePayloads {
+  text: string
+  thought: string
+  audio: { audioData: string; transcript: string }
+  setup_complete: string
+  interrupted: string
+  turn_complete: string
+  tool_call: LiveServerToolCall
+  session_resumption_update: LiveServerSessionResumptionUpdate
+  go_away: LiveServerGoAway
+  usage_metadata: UsageMetadata
+  error: string
+  input_transcription: { text: string; finished: boolean }
+  output_transcription: { text: string; finished: boolean }
+}
+
+export type MultimodalLiveResponseType = keyof LiveResponsePayloads
+
+export type LiveResponse = {
+  [K in MultimodalLiveResponseType]: {
+    type: K
+    data: LiveResponsePayloads[K]
+    endOfTurn: boolean
+  }
+}[MultimodalLiveResponseType]
+
+/**
+ * Parses response messages from the Gemini Live API
+ */
+/**
+ * Parses ALL response types from a single server message.
+ * The server can now bundle multiple fields (e.g. audio + transcription)
+ * in the same message. Returns an array of response objects.
+ */
+export function parseResponseMessages(
+  data: LiveServerMessage,
+): Array<LiveResponse> {
+  const responses: Array<LiveResponse> = []
+  const serverContent = data.serverContent
+  const parts = serverContent?.modelTurn?.parts
+
+  // Setup complete (exclusive — no other fields expected)
+  if (data.setupComplete) {
+    responses.push({ type: 'setup_complete', data: '', endOfTurn: false })
+    return responses
+  }
+
+  // Tool call (exclusive)
+  if (data.toolCall) {
+    responses.push({
+      type: 'tool_call',
+      data: data.toolCall,
+      endOfTurn: false,
+    })
+    return responses
+  }
+
+  if (data.sessionResumptionUpdate) {
+    responses.push({
+      type: 'session_resumption_update',
+      data: data.sessionResumptionUpdate,
+      endOfTurn: false,
+    })
+  }
+
+  if (data.goAway) {
+    responses.push({ type: 'go_away', data: data.goAway, endOfTurn: false })
+  }
+
+  if (data.usageMetadata) {
+    responses.push({
+      type: 'usage_metadata',
+      data: data.usageMetadata,
+      endOfTurn: false,
+    })
+  }
+
+  // Audio data from model turn parts
+  if (parts?.length) {
+    for (const part of parts) {
+      if (part.inlineData?.data) {
+        responses.push({
+          type: 'audio',
+          data: {
+            audioData: part.inlineData.data,
+            // The transcription is independent to the model turn, which means it doesn't imply any ordering between transcription and model turn.
+            transcript: '',
+          },
+          endOfTurn: false,
+        })
+      } else if (part.text) {
+        responses.push({
+          type: part.thought ? 'thought' : 'text',
+          data: part.text,
+          endOfTurn: false,
+        })
+      }
+    }
+  }
+
+  // Transcriptions — checked independently, NOT in else-if with audio
+  if (serverContent?.inputTranscription) {
+    responses.push({
+      type: 'input_transcription',
+      data: {
+        text: serverContent.inputTranscription.text || '',
+        finished: serverContent.inputTranscription.finished || false,
+      },
+      endOfTurn: false,
+    })
+  }
+
+  if (serverContent?.outputTranscription) {
+    responses.push({
+      type: 'output_transcription',
+      data: {
+        text: serverContent.outputTranscription.text || '',
+        finished: serverContent.outputTranscription.finished || false,
+      },
+      endOfTurn: false,
+    })
+  }
+
+  // Interrupted
+  if (serverContent?.interrupted) {
+    responses.push({ type: 'interrupted', data: '', endOfTurn: false })
+  }
+
+  // Turn complete
+  if (serverContent?.turnComplete) {
+    responses.push({ type: 'turn_complete', data: '', endOfTurn: true })
+  }
+
+  return responses
+}
+
+export class GeminiLiveClient {
+  private token: string | null = null
+  private model: GeminiRealtimeModel | null = null
+
+  private readonly responseModalities: Array<Modality> = [Modality.AUDIO]
+  private systemInstructions = ''
+  private googleGrounding = false
+  private voiceName: GeminiRealtimeVoice = 'Puck'
+  private temperature = 1.0
+  private inputAudioTranscription = false
+  private outputAudioTranscription = false
+  private contextWindowCompression: ContextWindowCompressionConfig | undefined
+  private proactiveAudio = false
+  private enableAffectiveDialog = false
+  private thinkingConfig: ThinkingConfig | undefined
+  private speechLanguageCode: string | undefined
+
+  private maxOutputTokens: number | undefined
+  private functionDeclarations: Array<FunctionDeclaration> = []
+
+  private readonly automaticActivityDetection = {
+    disabled: false,
+    silence_duration_ms: 2000,
+    prefix_padding_ms: 500,
+    end_of_speech_sensitivity: EndSensitivity.END_SENSITIVITY_UNSPECIFIED,
+    start_of_speech_sensitivity: StartSensitivity.START_SENSITIVITY_UNSPECIFIED,
+  }
+
+  private readonly activityHandling =
+    ActivityHandling.ACTIVITY_HANDLING_UNSPECIFIED
+
+  private webSocket: WebSocket | null = null
+  private lastResumptionUpdate: LiveServerSessionResumptionUpdate | null = null
+  private setupComplete = false
+  private connected = false
+
+  public onReceiveResponse: (response: LiveResponse) => void = () => {}
+  public onOpen: () => void = () => {}
+  public onClose: () => void = () => {}
+  public onError: (error: Error) => void = () => {}
+
+  constructor(
+    token: string,
+    model: GeminiRealtimeModel,
+    tools?: ReadonlyArray<AnyClientTool>,
+  ) {
+    this.token = token
+    this.model = model
+
+    if (tools) {
+      this.functionDeclarations = tools.map(clientToolToDeclaration)
+    }
+  }
+
+  get isConnected() {
+    return this.connected
+  }
+
+  get isSetupComplete() {
+    return this.setupComplete
+  }
+
+  /**
+   * Connection management
+   */
+  connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const socket = new WebSocket(
+        `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContentConstrained?access_token=${this.token}`,
+      )
+      this.webSocket = socket
+
+      // The browser fires `onerror` then `onclose` on an abnormal close; this
+      // flag stops the close handler from overwriting the surfaced error with a
+      // benign "closed" signal.
+      let errored = false
+
+      socket.onclose = () => {
+        this.connected = false
+        this.setupComplete = false
+        if (!errored) this.onClose()
+        reject(new Error('WebSocket closed before setup completed'))
+      }
+
+      socket.onerror = () => {
+        errored = true
+        this.connected = false
+        this.setupComplete = false
+        const error = new Error('Gemini realtime WebSocket connection error')
+        this.onError(error)
+        reject(error)
+      }
+
+      socket.onopen = () => {
+        this.connected = true
+        this.onOpen()
+        resolve()
+      }
+
+      socket.onmessage = (event) => {
+        void this.onReceiveMessage(event)
+      }
+    })
+  }
+
+  disconnect() {
+    if (this.webSocket) {
+      // Detach handlers first so a deliberate teardown (e.g. during a
+      // reconnect) doesn't emit a spurious close/error to the client.
+      this.webSocket.onclose = null
+      this.webSocket.onerror = null
+      this.webSocket.onopen = null
+      this.webSocket.onmessage = null
+      this.webSocket.close()
+      this.webSocket = null
+    }
+    this.connected = false
+    this.setupComplete = false
+  }
+
+  /**
+   * Session management
+   */
+  sendInitialSetupMessage(resume = false) {
+    const tools = this.functionDeclarations
+
+    const setup: NonNullable<LiveClientMessage['setup']> = {
+      model: `models/${this.model}`,
+      generationConfig: {
+        responseModalities: this.responseModalities,
+        temperature: this.temperature,
+        speechConfig: {
+          languageCode: this.speechLanguageCode,
+          voiceConfig: {
+            prebuiltVoiceConfig: {
+              voiceName: this.voiceName,
+            },
+          },
+        },
+        enableAffectiveDialog: this.enableAffectiveDialog,
+        maxOutputTokens: this.maxOutputTokens,
+        thinkingConfig: this.thinkingConfig,
+      },
+      sessionResumption: {
+        transparent: true,
+        handle: resume ? this.lastResumptionUpdate?.newHandle : undefined,
+      },
+      contextWindowCompression: this.contextWindowCompression,
+      proactivity: {
+        proactiveAudio: this.proactiveAudio,
+      },
+      systemInstruction: { parts: [{ text: this.systemInstructions }] },
+      tools: [{ functionDeclarations: tools }],
+      realtimeInputConfig: {
+        automaticActivityDetection: {
+          disabled: this.automaticActivityDetection.disabled,
+          silenceDurationMs:
+            this.automaticActivityDetection.silence_duration_ms,
+          prefixPaddingMs: this.automaticActivityDetection.prefix_padding_ms,
+          endOfSpeechSensitivity:
+            this.automaticActivityDetection.end_of_speech_sensitivity,
+          startOfSpeechSensitivity:
+            this.automaticActivityDetection.start_of_speech_sensitivity,
+        },
+        activityHandling: this.activityHandling,
+        turnCoverage: TurnCoverage.TURN_INCLUDES_ONLY_ACTIVITY,
+      },
+    }
+
+    if (this.inputAudioTranscription) {
+      setup.inputAudioTranscription = {}
+    }
+
+    if (this.outputAudioTranscription) {
+      setup.outputAudioTranscription = {}
+    }
+
+    if (this.googleGrounding) {
+      // Currently can't have both Google Search with custom tools.
+      console.warn(
+        'Google Grounding enabled, removing custom function calls if any.',
+      )
+      setup.tools = [{ googleSearch: {} }]
+    }
+
+    this.sendMessage({ setup })
+  }
+
+  async restartSession(resume = false) {
+    this.disconnect()
+    await this.connect()
+    this.sendInitialSetupMessage(resume)
+  }
+
+  updateToken(token: RealtimeToken) {
+    this.token = token.token
+
+    // Restart completely with the new model, or resume the existing session.
+    const resume = !(token.config.model && this.model != token.config.model)
+    if (!resume) {
+      this.model = token.config.model as GeminiRealtimeModel
+    }
+    this.restartSession(resume).catch((err) =>
+      this.onError(err instanceof Error ? err : new Error(String(err))),
+    )
+  }
+
+  async updateSession(config: Partial<RealtimeSessionConfig>) {
+    // model can only be set during initial setup
+    if (config.model && !this.setupComplete) {
+      this.model = config.model as GeminiRealtimeModel
+    }
+
+    if (config.instructions) {
+      this.systemInstructions = config.instructions
+    }
+
+    if (config.tools) {
+      this.functionDeclarations = config.tools.map(toolConfigToDeclaration)
+    }
+
+    if (config.maxOutputTokens) {
+      // Gemini has no "inf" sentinel; treat it as "no explicit limit".
+      this.maxOutputTokens =
+        typeof config.maxOutputTokens === 'number'
+          ? config.maxOutputTokens
+          : undefined
+    }
+
+    if (config.temperature) {
+      this.temperature = config.temperature
+    }
+
+    if (config.voice) {
+      this.voiceName = config.voice as GeminiRealtimeVoice
+    }
+
+    const providerOptions = config.providerOptions as
+      | GeminiRealtimeProviderOptions
+      | undefined
+
+    if (providerOptions?.googleGrounding) {
+      this.googleGrounding = providerOptions.googleGrounding
+    }
+
+    if (providerOptions?.proactiveAudio) {
+      this.proactiveAudio = providerOptions.proactiveAudio
+    }
+
+    if (providerOptions?.enableAffectiveDialog) {
+      this.enableAffectiveDialog = providerOptions.enableAffectiveDialog
+    }
+
+    if (providerOptions?.contextWindowCompression) {
+      this.contextWindowCompression = providerOptions.contextWindowCompression
+    }
+
+    if (providerOptions?.thinkingConfig) {
+      this.thinkingConfig = providerOptions.thinkingConfig
+    }
+
+    if (providerOptions?.languageCode) {
+      this.speechLanguageCode = providerOptions.languageCode
+    }
+
+    const includeTranscription =
+      config.outputModalities?.includes('text') || false
+    this.inputAudioTranscription = includeTranscription
+    this.outputAudioTranscription = includeTranscription
+
+    if (!this.setupComplete) {
+      this.sendInitialSetupMessage()
+    } else {
+      return this.restartSession(true)
+    }
+  }
+
+  /**
+   * Message transmission & receiving
+   */
+  sendMessage(message: LiveClientMessage) {
+    if (this.webSocket?.readyState === WebSocket.OPEN) {
+      this.webSocket.send(JSON.stringify(message))
+    } else {
+      this.onError(
+        new Error('Cannot send message: Gemini realtime socket is not open'),
+      )
+    }
+  }
+
+  async onReceiveMessage(messageEvent: MessageEvent) {
+    let jsonData
+    if (messageEvent.data instanceof Blob) {
+      jsonData = await messageEvent.data.text()
+    } else if (messageEvent.data instanceof ArrayBuffer) {
+      jsonData = new TextDecoder().decode(messageEvent.data)
+    } else {
+      jsonData = messageEvent.data
+    }
+
+    try {
+      const messageData = JSON.parse(jsonData)
+      // Parse all response types from this message (audio + transcription can coexist)
+      const responses = parseResponseMessages(messageData)
+      for (const response of responses) {
+        if (
+          response.type === 'session_resumption_update' &&
+          response.data.resumable
+        ) {
+          this.lastResumptionUpdate = response.data
+        }
+        if (response.type === 'setup_complete') {
+          this.setupComplete = true
+        }
+        this.onReceiveResponse(response)
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)))
+    }
+  }
+
+  sendRealtimeInputMessage(data: string, mimeType: string) {
+    const blob = { mimeType, data }
+
+    if (mimeType.startsWith('audio/')) {
+      this.sendMessage({ realtimeInput: { audio: blob } })
+    } else if (mimeType.startsWith('image/') || mimeType.startsWith('video/')) {
+      this.sendMessage({ realtimeInput: { video: blob } })
+    }
+  }
+
+  sendAudioMessage(base64PCM: string) {
+    this.sendRealtimeInputMessage(base64PCM, 'audio/pcm')
+  }
+
+  sendImageMessage(base64: string, mimeType = 'image/jpeg') {
+    this.sendRealtimeInputMessage(base64, mimeType)
+  }
+
+  sendTextMessage(text: string) {
+    const message: LiveClientMessage = {
+      realtimeInput: {
+        text,
+      },
+    }
+    this.sendMessage(message)
+  }
+
+  sendToolResponse(functionResponses: Array<FunctionResponse>) {
+    const message: LiveClientMessage = {
+      toolResponse: {
+        functionResponses,
+      },
+    }
+    this.sendMessage(message)
+  }
+}
diff --git a/packages/ai-gemini/src/realtime/index.ts b/packages/ai-gemini/src/realtime/index.ts
new file mode 100644
index 000000000..48e60b44f
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/index.ts
@@ -0,0 +1,14 @@
+// Token adapter for server-side use
+export { geminiRealtimeToken } from './token'
+
+// Client adapter for browser use
+export { geminiRealtime } from './adapter'
+
+// Types
+export type {
+  GeminiRealtimeModel,
+  GeminiRealtimeVoice,
+  GeminiRealtimeTokenOptions,
+  GeminiRealtimeOptions,
+  GeminiRealtimeProviderOptions,
+} from './types'
diff --git a/packages/ai-gemini/src/realtime/token.ts b/packages/ai-gemini/src/realtime/token.ts
new file mode 100644
index 000000000..749cf77af
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/token.ts
@@ -0,0 +1,70 @@
+import { GoogleGenAI } from '@google/genai'
+import { getGeminiApiKeyFromEnv } from '../utils'
+import type { RealtimeToken, RealtimeTokenAdapter } from '@tanstack/ai'
+import type { GeminiRealtimeTokenOptions } from './types'
+
+/**
+ * Creates a Google Gemini realtime token adapter.
+ *
+ * This adapter generates ephemeral tokens for client-side WebSocket connections.
+ *
+ * @param options - Configuration options for the realtime session
+ * @returns A RealtimeTokenAdapter for use with realtimeToken()
+ *
+ * @example
+ * ```typescript
+ * import { realtimeToken } from '@tanstack/ai'
+ * import { geminiRealtimeToken } from '@tanstack/ai-gemini'
+ *
+ * const token = await realtimeToken({
+ *   adapter: geminiRealtimeToken({
+ *     // Optional: constraint model config by token
+ *     liveConnectConstraints: {
+ *       model: 'gemini-3.1-flash-live-preview',
+ *     },
+ *   }),
+ * })
+ * ```
+ */
+export function geminiRealtimeToken(
+  options: GeminiRealtimeTokenOptions = {},
+): RealtimeTokenAdapter {
+  const apiKey = getGeminiApiKeyFromEnv()
+
+  const client = new GoogleGenAI({
+    apiKey,
+  })
+
+  return {
+    provider: 'gemini',
+    async generateToken(): Promise<RealtimeToken> {
+      // Computed per call so a reused adapter doesn't mint tokens with a
+      // fixed (and eventually past) expiry. Defaults to 30 minutes.
+      const expireTime = options.expiresAt ?? Date.now() + 30 * 60 * 1000
+
+      const token = await client.authTokens.create({
+        config: {
+          uses: options.uses ?? 1,
+          expireTime: new Date(expireTime).toISOString(),
+          liveConnectConstraints: options.liveConnectConstraints,
+          httpOptions: {
+            apiVersion: 'v1alpha',
+          },
+        },
+      })
+
+      if (!token.name) {
+        throw new Error('Gemini realtime token creation failed')
+      }
+
+      return {
+        provider: 'gemini',
+        token: token.name,
+        expiresAt: expireTime,
+        config: {
+          model: options.liveConnectConstraints?.model,
+        },
+      }
+    },
+  }
+}
diff --git a/packages/ai-gemini/src/realtime/types.ts b/packages/ai-gemini/src/realtime/types.ts
new file mode 100644
index 000000000..4e834c570
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/types.ts
@@ -0,0 +1,94 @@
+import type {
+  ContextWindowCompressionConfig,
+  LiveConnectConstraints,
+  ThinkingConfig,
+} from '@google/genai'
+
+/**
+ * Gemini realtime voice options
+ */
+export type GeminiRealtimeVoice =
+  | 'Achernar'
+  | 'Achird'
+  | 'Algenib'
+  | 'Algieba'
+  | 'Alnilam'
+  | 'Aoede'
+  | 'Autonoe'
+  | 'Callirrhoe'
+  | 'Charon'
+  | 'Despina'
+  | 'Enceladus'
+  | 'Erinome'
+  | 'Fenrir'
+  | 'Gacrux'
+  | 'Iapetus'
+  | 'Kore'
+  | 'Laomedeia'
+  | 'Leda'
+  | 'Orus'
+  | 'Pulcherrima'
+  | 'Puck'
+  | 'Rasalgethi'
+  | 'Sadachbia'
+  | 'Sadaltager'
+  | 'Schedar'
+  | 'Sulafat'
+  | 'Umbriel'
+  | 'Vindemiatrix'
+  | 'Zephyr'
+  | 'Zubenelgenubi'
+
+/**
+ * Gemini realtime model options
+ */
+export type GeminiRealtimeModel = 'gemini-3.1-flash-live-preview'
+
+/**
+ * Options for the Gemini realtime client adapter
+ */
+export interface GeminiRealtimeOptions {
+  /** Connection mode (default: 'websocket' in browser) */
+  connectionMode?: 'websocket'
+  model?: GeminiRealtimeModel
+}
+
+export interface StrictLiveConnectionConstraints extends Omit<
+  LiveConnectConstraints,
+  'model'
+> {
+  model?: GeminiRealtimeModel
+}
+
+/**
+ * Options for the Gemini realtime token adapter
+ */
+export interface GeminiRealtimeTokenOptions {
+  expiresAt?: number
+  uses?: number
+  /**
+   * Config for LiveConnectConstraints for Auth Token creation.
+   *
+   * NOTE: Adding liveConnectConstraints will cause the API to ignore any config passed later to WebSocket.
+   */
+  liveConnectConstraints?: StrictLiveConnectionConstraints
+}
+
+/**
+ * Gemini-specific realtime options, passed through `providerOptions` on a
+ * realtime session config.
+ */
+export interface GeminiRealtimeProviderOptions {
+  /** Enable Google Search grounding (mutually exclusive with custom tools). */
+  googleGrounding?: boolean
+  /** Enable proactive audio so the model may choose when to respond. */
+  proactiveAudio?: boolean
+  /** Enable affective (emotion-aware) dialog. */
+  enableAffectiveDialog?: boolean
+  /** Context window compression configuration. */
+  contextWindowCompression?: ContextWindowCompressionConfig
+  /** Thinking configuration. */
+  thinkingConfig?: ThinkingConfig
+  /** BCP-47 language code for speech output. */
+  languageCode?: string
+}
diff --git a/packages/ai-gemini/src/realtime/utils.ts b/packages/ai-gemini/src/realtime/utils.ts
new file mode 100644
index 000000000..6c9c75268
--- /dev/null
+++ b/packages/ai-gemini/src/realtime/utils.ts
@@ -0,0 +1,439 @@
+import type { GeminiLiveClient } from './client'
+
+/**
+ * Audio Worklet Processor for capturing and processing audio
+ */
+const captureWorkletCode = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.bufferSize = 512; // 32ms at 16kHz — per Gemini best practices (20-40ms chunks)
+    this.buffer = new Float32Array(this.bufferSize);
+    this.bufferIndex = 0;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+
+    if (input && input.length > 0) {
+      const inputChannel = input[0];
+
+      // Buffer the incoming audio
+      for (let i = 0; i < inputChannel.length; i++) {
+        this.buffer[this.bufferIndex++] = inputChannel[i];
+
+        // When buffer is full, send it to main thread
+        if (this.bufferIndex >= this.bufferSize) {
+          // Send the buffered audio to the main thread
+          this.port.postMessage({
+            type: "audio",
+            data: this.buffer.slice(),
+          });
+
+          // Reset buffer
+          this.bufferIndex = 0;
+        }
+      }
+    }
+
+    // Return true to keep the processor alive
+    return true;
+  }
+}
+
+// Register the processor
+registerProcessor("audio-capture-processor", AudioCaptureProcessor);`
+
+/**
+ * Audio Playback Worklet Processor for playing PCM audio.
+ * Uses an offset tracker instead of slice() to avoid allocations
+ * on the real-time audio thread.
+ */
+const playbackWorkletCode = `
+class PCMProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.audioQueue = [];
+    this.currentOffset = 0; // Track position in current buffer (avoids slice())
+
+    this.port.onmessage = (event) => {
+      if (event.data === "interrupt") {
+        // Clear the queue on interrupt
+        this.audioQueue = [];
+        this.currentOffset = 0;
+      } else if (event.data instanceof Float32Array) {
+        // Add audio data to the queue
+        this.audioQueue.push(event.data);
+      }
+    };
+  }
+
+  process(inputs, outputs, parameters) {
+    const output = outputs[0];
+    if (output.length === 0) return true;
+
+    const channel = output[0];
+    let outputIndex = 0;
+
+    // Fill the output buffer from the queue
+    while (outputIndex < channel.length && this.audioQueue.length > 0) {
+      const currentBuffer = this.audioQueue[0];
+
+      if (!currentBuffer || currentBuffer.length === 0) {
+        this.audioQueue.shift();
+        this.currentOffset = 0;
+        continue;
+      }
+
+      const remainingOutput = channel.length - outputIndex;
+      const remainingBuffer = currentBuffer.length - this.currentOffset;
+      const copyLength = Math.min(remainingOutput, remainingBuffer);
+
+      // Copy audio data to output using offset (no slice allocation)
+      for (let i = 0; i < copyLength; i++) {
+        channel[outputIndex++] = currentBuffer[this.currentOffset++];
+      }
+
+      // If we've consumed the entire buffer, move to the next one
+      if (this.currentOffset >= currentBuffer.length) {
+        this.audioQueue.shift();
+        this.currentOffset = 0;
+      }
+    }
+
+    // Fill remaining output with silence
+    while (outputIndex < channel.length) {
+      channel[outputIndex++] = 0;
+    }
+
+    return true;
+  }
+}
+
+registerProcessor("pcm-processor", PCMProcessor);`
+
+function calculateLevel(analyser: AnalyserNode): number {
+  const data = new Uint8Array(analyser.fftSize)
+  analyser.getByteTimeDomainData(data)
+
+  // Find peak deviation from center (128 is silence)
+  // This is more responsive than RMS for voice level meters
+  let maxDeviation = 0
+  for (const sample of data) {
+    const deviation = Math.abs(sample - 128)
+    if (deviation > maxDeviation) {
+      maxDeviation = deviation
+    }
+  }
+
+  // Normalize to 0-1 range (max deviation is 128)
+  // Scale by 1.5x so that ~66% amplitude reads as full scale
+  // This provides good visual feedback without pegging too early
+  const normalized = maxDeviation / 128
+  return Math.min(1, normalized * 1.5)
+}
+
+export function base64ToArrayBuffer(base64: string): ArrayBuffer {
+  const binary = atob(base64)
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0))
+  return bytes.buffer
+}
+
+// Empty arrays for when visualization isn't available
+// frequencyBinCount = fftSize / 2 = 1024
+const emptyFrequencyData = new Uint8Array(1024)
+const emptyTimeDomainData = new Uint8Array(2048).fill(128) // 128 is silence
+
+export class AudioStreamer {
+  private audioContext: AudioContext | null = null
+  private audioWorklet: AudioWorkletNode | null = null
+  private mediaStream: MediaStream | null = null
+  private analyser: AnalyserNode | null = null
+  private isStreaming = false
+  private readonly sampleRate = 16000
+  private readonly client: GeminiLiveClient | null = null
+
+  constructor(client: GeminiLiveClient) {
+    this.client = client
+  }
+
+  get inputLevel() {
+    if (!this.analyser) return 0
+    return calculateLevel(this.analyser)
+  }
+
+  get inputFrequencyData() {
+    if (!this.analyser) return emptyFrequencyData
+    const data = new Uint8Array(this.analyser.frequencyBinCount)
+    this.analyser.getByteFrequencyData(data)
+    return data
+  }
+
+  get inputTimeDomainData() {
+    if (!this.analyser) return emptyTimeDomainData
+    const data = new Uint8Array(this.analyser.fftSize)
+    this.analyser.getByteTimeDomainData(data)
+    return data
+  }
+
+  get inputSampleRate() {
+    return this.sampleRate
+  }
+
+  async start() {
+    try {
+      const audioConstraints: MediaTrackConstraints = {
+        sampleRate: this.sampleRate,
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+      }
+
+      // Get microphone access
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: audioConstraints,
+      })
+
+      // Check if native AGC is active
+      const track = this.mediaStream.getAudioTracks()[0]
+      const settings = track?.getSettings()
+
+      if (settings?.autoGainControl) {
+        console.warn('Native AGC not supported.')
+      }
+
+      // Create audio context
+      this.audioContext = new AudioContext({
+        sampleRate: this.sampleRate,
+      })
+
+      if (this.audioContext.state === 'suspended') {
+        await this.audioContext.resume()
+      }
+
+      const workletBlob = new Blob([captureWorkletCode], {
+        type: 'application/javascript',
+      })
+      const workletUrl = URL.createObjectURL(workletBlob)
+
+      // Load the audio worklet module, then release the blob URL.
+      await this.audioContext.audioWorklet.addModule(workletUrl)
+      URL.revokeObjectURL(workletUrl)
+
+      // Create the audio worklet node
+      this.audioWorklet = new AudioWorkletNode(
+        this.audioContext,
+        'audio-capture-processor',
+      )
+
+      // Set up message handling from the worklet
+      this.audioWorklet.port.onmessage = (event) => {
+        if (!this.isStreaming) return
+
+        if (event.data.type === 'audio') {
+          const inputData = event.data.data
+          const pcmData = this.convertToPCM16(inputData)
+          const base64Audio = this.arrayBufferToBase64(pcmData)
+
+          // Send to Gemini only if after setup complete
+          if (this.client?.isSetupComplete) {
+            this.client.sendAudioMessage(base64Audio)
+          }
+        }
+      }
+
+      // Create analyser for volume detection
+      this.analyser = this.audioContext.createAnalyser()
+      this.analyser.fftSize = 2048 // Larger size for more accurate level detection
+      this.analyser.smoothingTimeConstant = 0.3
+
+      // Connect the audio graph
+      const source = this.audioContext.createMediaStreamSource(this.mediaStream)
+      source.connect(this.analyser)
+      this.analyser.connect(this.audioWorklet)
+
+      // Start streaming
+      this.isStreaming = true
+    } catch (error) {
+      // Clean up the mic + audio context if setup failed partway through.
+      this.stop()
+      throw error
+    }
+  }
+
+  stop() {
+    this.isStreaming = false
+
+    if (this.audioWorklet) {
+      this.audioWorklet.disconnect()
+      this.audioWorklet.port.close()
+      this.audioWorklet = null
+    }
+
+    if (this.audioContext) {
+      void this.audioContext.close()
+      this.audioContext = null
+    }
+
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach((track) => track.stop())
+      this.mediaStream = null
+    }
+  }
+
+  startAudioCapture() {
+    if (this.mediaStream) {
+      for (const track of this.mediaStream.getAudioTracks()) {
+        track.enabled = true
+      }
+    }
+    this.isStreaming = true
+  }
+
+  stopAudioCapture() {
+    if (this.mediaStream) {
+      // Disable tracks rather than stopping them to allow re-enabling
+      for (const track of this.mediaStream.getAudioTracks()) {
+        track.enabled = false
+      }
+    }
+    this.isStreaming = false
+  }
+
+  private convertToPCM16(float32Array: Float32Array): ArrayBuffer {
+    const int16Array = new Int16Array(float32Array.length)
+    for (let i = 0; i < float32Array.length; i++) {
+      const sample = Math.max(-1, Math.min(1, float32Array[i] ?? 0))
+      int16Array[i] = sample * 0x7fff
+    }
+    return int16Array.buffer
+  }
+
+  private arrayBufferToBase64(buffer: ArrayBuffer): string {
+    const bytes = new Uint8Array(buffer)
+    const binary = String.fromCharCode(...bytes)
+    return btoa(binary)
+  }
+}
+
+export class AudioPlayer {
+  private audioContext: AudioContext | null = null
+  private workletNode: AudioWorkletNode | null = null
+  private gainNode: GainNode | null = null
+  private analyser: AnalyserNode | null = null
+  private isInitialized = false
+  private volume = 1.0
+  private readonly sampleRate = 24000
+
+  get outputLevel() {
+    if (!this.analyser) return 0
+    return calculateLevel(this.analyser)
+  }
+
+  get outputFrequencyData() {
+    if (!this.analyser) return emptyFrequencyData
+    const data = new Uint8Array(this.analyser.frequencyBinCount)
+    this.analyser.getByteFrequencyData(data)
+    return data
+  }
+
+  get outputTimeDomainData() {
+    if (!this.analyser) return emptyTimeDomainData
+    const data = new Uint8Array(this.analyser.fftSize)
+    this.analyser.getByteTimeDomainData(data)
+    return data
+  }
+
+  get outputSampleRate() {
+    return this.sampleRate
+  }
+
+  async init() {
+    if (this.isInitialized) return
+
+    try {
+      // Create audio context at 24kHz to match Gemini
+      this.audioContext = new AudioContext({
+        sampleRate: this.sampleRate,
+      })
+
+      const workletBlob = new Blob([playbackWorkletCode], {
+        type: 'application/javascript',
+      })
+      const workletUrl = URL.createObjectURL(workletBlob)
+
+      // Load the audio worklet module, then release the blob URL.
+      await this.audioContext.audioWorklet.addModule(workletUrl)
+      URL.revokeObjectURL(workletUrl)
+
+      // Create worklet node
+      this.workletNode = new AudioWorkletNode(
+        this.audioContext,
+        'pcm-processor',
+      )
+
+      // Create gain node for volume control
+      this.gainNode = this.audioContext.createGain()
+      this.gainNode.gain.value = this.volume
+
+      // Create analyser for volume detection
+      this.analyser = this.audioContext.createAnalyser()
+      this.analyser.fftSize = 2048 // Larger size for more accurate level detection
+      this.analyser.smoothingTimeConstant = 0.3
+
+      // Connect nodes
+      this.workletNode.connect(this.gainNode)
+      this.gainNode.connect(this.analyser)
+      this.analyser.connect(this.audioContext.destination)
+
+      this.isInitialized = true
+    } catch (error) {
+      // Release the audio context if initialization failed partway through.
+      this.destroy()
+      throw error
+    }
+  }
+
+  async play(pcmData: ArrayBuffer) {
+    if (!this.isInitialized) {
+      await this.init()
+    }
+
+    // Resume audio context if suspended
+    if (this.audioContext?.state === 'suspended') {
+      await this.audioContext.resume()
+    }
+
+    // Convert PCM16 LE to Float32
+    const inputArray = new Int16Array(pcmData)
+    const float32Data = new Float32Array(inputArray.length)
+    for (let i = 0; i < inputArray.length; i++) {
+      float32Data[i] = (inputArray[i] ?? 0) / 32768
+    }
+
+    // Send to worklet for playback
+    this.workletNode?.port.postMessage(float32Data)
+  }
+
+  /* Interrupt playback */
+  interrupt() {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage('interrupt')
+    }
+  }
+
+  setVolume(volume: number) {
+    this.volume = Math.max(0, Math.min(1, volume))
+    if (this.gainNode) {
+      this.gainNode.gain.value = this.volume
+    }
+  }
+
+  destroy() {
+    if (this.audioContext) {
+      void this.audioContext.close()
+      this.audioContext = null
+    }
+    this.isInitialized = false
+  }
+}
diff --git a/packages/ai-gemini/tests/realtime-parse.test.ts b/packages/ai-gemini/tests/realtime-parse.test.ts
new file mode 100644
index 000000000..afbc9f0a2
--- /dev/null
+++ b/packages/ai-gemini/tests/realtime-parse.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest'
+import { parseResponseMessages } from '../src/realtime/client'
+import type { LiveServerMessage } from '@google/genai'
+
+describe('parseResponseMessages', () => {
+  it('maps setup completion exclusively', () => {
+    const responses = parseResponseMessages({
+      setupComplete: {},
+      // A real message never bundles these with setupComplete, but assert the
+      // "exclusive" short-circuit ignores anything else present.
+      serverContent: { turnComplete: true },
+    } as LiveServerMessage)
+
+    expect(responses).toEqual([
+      { type: 'setup_complete', data: '', endOfTurn: false },
+    ])
+  })
+
+  it('maps tool calls exclusively', () => {
+    const toolCall = { functionCalls: [{ id: '1', name: 'getTime', args: {} }] }
+    const responses = parseResponseMessages({
+      toolCall,
+    } as LiveServerMessage)
+
+    expect(responses).toEqual([
+      { type: 'tool_call', data: toolCall, endOfTurn: false },
+    ])
+  })
+
+  it('emits audio and input/output transcription from one bundled message', () => {
+    const responses = parseResponseMessages({
+      serverContent: {
+        modelTurn: { parts: [{ inlineData: { data: 'AAAA' } }] },
+        inputTranscription: { text: 'hello', finished: true },
+        outputTranscription: { text: 'hi', finished: false },
+      },
+    } as LiveServerMessage)
+
+    expect(responses.map((r) => r.type)).toEqual([
+      'audio',
+      'input_transcription',
+      'output_transcription',
+    ])
+    const input = responses.find((r) => r.type === 'input_transcription')
+    expect(input).toMatchObject({ data: { text: 'hello', finished: true } })
+  })
+
+  it('distinguishes thought parts from text parts', () => {
+    const responses = parseResponseMessages({
+      serverContent: {
+        modelTurn: {
+          parts: [{ text: 'thinking...', thought: true }, { text: 'answer' }],
+        },
+      },
+    } as LiveServerMessage)
+
+    expect(responses).toEqual([
+      { type: 'thought', data: 'thinking...', endOfTurn: false },
+      { type: 'text', data: 'answer', endOfTurn: false },
+    ])
+  })
+
+  it('maps go_away, usage and turn completion', () => {
+    const goAway = parseResponseMessages({
+      goAway: { timeLeft: '5s' },
+    } as LiveServerMessage)
+    expect(goAway[0]).toMatchObject({
+      type: 'go_away',
+      data: { timeLeft: '5s' },
+    })
+
+    const usage = parseResponseMessages({
+      usageMetadata: { totalTokenCount: 10 },
+    } as LiveServerMessage)
+    expect(usage[0]?.type).toBe('usage_metadata')
+
+    const turn = parseResponseMessages({
+      serverContent: { turnComplete: true },
+    } as LiveServerMessage)
+    expect(turn).toEqual([{ type: 'turn_complete', data: '', endOfTurn: true }])
+  })
+
+  it('returns an empty array for an empty message', () => {
+    expect(parseResponseMessages({} as LiveServerMessage)).toEqual([])
+  })
+})
diff --git a/packages/ai-gemini/tests/realtime-token.test.ts b/packages/ai-gemini/tests/realtime-token.test.ts
new file mode 100644
index 000000000..f59bec2e0
--- /dev/null
+++ b/packages/ai-gemini/tests/realtime-token.test.ts
@@ -0,0 +1,55 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { geminiRealtimeToken } from '../src/realtime/token'
+
+const mocks = vi.hoisted(() => ({
+  createSpy: vi.fn(),
+}))
+
+vi.mock('@google/genai', async () => {
+  const actual = await vi.importActual('@google/genai')
+  class MockGoogleGenAI {
+    public authTokens = { create: mocks.createSpy }
+    constructor(_options: { apiKey: string }) {}
+  }
+  return { ...actual, GoogleGenAI: MockGoogleGenAI }
+})
+
+describe('geminiRealtimeToken', () => {
+  beforeEach(() => {
+    process.env.GOOGLE_API_KEY = 'test-key'
+    mocks.createSpy.mockReset()
+    mocks.createSpy.mockImplementation(
+      (args: { config: { expireTime: string } }) =>
+        Promise.resolve({ name: `tok-${args.config.expireTime}` }),
+    )
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('computes expiry per generateToken call, not once at adapter creation', async () => {
+    vi.useFakeTimers()
+    const start = new Date('2026-07-08T00:00:00.000Z').getTime()
+    vi.setSystemTime(start)
+
+    const adapter = geminiRealtimeToken()
+    const first = await adapter.generateToken()
+    expect(first.expiresAt).toBe(start + 30 * 60 * 1000)
+
+    // Advance 40 minutes and mint again from the SAME adapter. With the old
+    // factory-scoped expiry both tokens shared one (now-past) timestamp.
+    vi.setSystemTime(start + 40 * 60 * 1000)
+    const second = await adapter.generateToken()
+
+    expect(second.expiresAt).toBe(start + 70 * 60 * 1000)
+    expect(second.expiresAt).toBeGreaterThan(first.expiresAt)
+  })
+
+  it('throws when the provider returns no token name', async () => {
+    mocks.createSpy.mockResolvedValueOnce({})
+    await expect(geminiRealtimeToken().generateToken()).rejects.toThrow(
+      'Gemini realtime token creation failed',
+    )
+  })
+})
diff --git a/packages/ai-react/src/realtime-types.ts b/packages/ai-react/src/realtime-types.ts
index bad512d29..e58150237 100644
--- a/packages/ai-react/src/realtime-types.ts
+++ b/packages/ai-react/src/realtime-types.ts
@@ -2,8 +2,10 @@ import type {
   AnyClientTool,
   RealtimeMessage,
   RealtimeMode,
+  RealtimeSessionConfig,
   RealtimeStatus,
   RealtimeToken,
+  UsageInfo,
 } from '@tanstack/ai'
 import type { RealtimeAdapter } from '@tanstack/ai-client'
 
@@ -79,6 +81,9 @@ export interface UseRealtimeChatOptions {
   onMessage?: (message: RealtimeMessage) => void
   onModeChange?: (mode: RealtimeMode) => void
   onInterrupted?: () => void
+  onUsage?: (usage: UsageInfo) => void
+  onGoAway?: (timeLeft?: string) => void
+  onStatusChange?: (status: RealtimeStatus) => void
 }
 
 /**
@@ -135,9 +140,6 @@ export interface UseRealtimeChatReturn {
   /** Get time domain data for output waveform */
   getOutputTimeDomainData: () => Uint8Array
 
-  // VAD control
-  /** Current VAD mode */
-  vadMode: 'server' | 'semantic' | 'manual'
-  /** Change VAD mode at runtime */
-  setVADMode: (mode: 'server' | 'semantic' | 'manual') => void
+  // Session control
+  updateSession: (config: RealtimeSessionConfig) => void
 }
diff --git a/packages/ai-react/src/use-realtime-chat.ts b/packages/ai-react/src/use-realtime-chat.ts
index 4ec95c5f8..bddef502c 100644
--- a/packages/ai-react/src/use-realtime-chat.ts
+++ b/packages/ai-react/src/use-realtime-chat.ts
@@ -3,6 +3,7 @@ import { RealtimeClient } from '@tanstack/ai-client'
 import type {
   RealtimeMessage,
   RealtimeMode,
+  RealtimeSessionConfig,
   RealtimeStatus,
 } from '@tanstack/ai'
 import type {
@@ -70,9 +71,6 @@ export function useRealtimeChat(
   const [error, setError] = useState<Error | null>(null)
   const [inputLevel, setInputLevel] = useState(0)
   const [outputLevel, setOutputLevel] = useState(0)
-  const [vadMode, setVADModeState] = useState<'server' | 'semantic' | 'manual'>(
-    options.vadMode ?? 'server',
-  )
 
   // Refs
   const clientRef = useRef<RealtimeClient | null>(null)
@@ -126,6 +124,12 @@ export function useRealtimeChat(
         setMessages((prev) => [...prev, message])
         optionsRef.current.onMessage?.(message)
       },
+      onUsage(usage) {
+        optionsRef.current.onUsage?.(usage)
+      },
+      onGoAway(timeLeft) {
+        optionsRef.current.onGoAway?.(timeLeft)
+      },
       onError: (err) => {
         setError(err)
         optionsRef.current.onError?.(err)
@@ -248,14 +252,9 @@ export function useRealtimeChat(
     )
   }, [])
 
-  // VAD mode control
-  const setVADMode = useCallback(
-    (newMode: 'server' | 'semantic' | 'manual') => {
-      setVADModeState(newMode)
-      // TODO: Update session config if connected
-    },
-    [],
-  )
+  const updateSession = useCallback((config: RealtimeSessionConfig) => {
+    clientRef.current?.updateSession(config)
+  }, [])
 
   return {
     // Connection state
@@ -289,8 +288,7 @@ export function useRealtimeChat(
     getInputTimeDomainData,
     getOutputTimeDomainData,
 
-    // VAD control
-    vadMode,
-    setVADMode,
+    // Session control
+    updateSession,
   }
 }
diff --git a/packages/ai/src/index.ts b/packages/ai/src/index.ts
index 194e04729..102987c02 100644
--- a/packages/ai/src/index.ts
+++ b/packages/ai/src/index.ts
@@ -179,12 +179,13 @@ export { normalizeSystemPrompts } from './system-prompts'
 export { detectImageMimeType } from './utils'
 
 // Realtime
-export { realtimeToken } from './realtime/index'
+export { realtimeToken, createRealtimeEventEmitter } from './realtime/index'
 export type {
   RealtimeToken,
   RealtimeTokenAdapter,
   RealtimeTokenOptions,
   RealtimeSessionConfig,
+  RealtimeToolConfig,
   VADConfig,
   RealtimeMessage,
   RealtimeMessagePart,
diff --git a/packages/ai/src/realtime/event-emitter.ts b/packages/ai/src/realtime/event-emitter.ts
new file mode 100644
index 000000000..803c61040
--- /dev/null
+++ b/packages/ai/src/realtime/event-emitter.ts
@@ -0,0 +1,46 @@
+import type {
+  RealtimeEvent,
+  RealtimeEventHandler,
+  RealtimeEventPayloads,
+} from './types'
+
+/**
+ * Handlers are stored with a `never` payload so any specific
+ * `RealtimeEventHandler<TEvent>` is assignable in (contravariance), keeping the
+ * heterogeneous handler map type-safe without `any`. `emit` narrows back to the
+ * event's real payload type via its signature; the lone `as never` at the call
+ * site is the inverse of that stored `never`.
+ */
+type StoredHandler = (payload: never) => void
+
+export function createRealtimeEventEmitter() {
+  const eventHandlers = new Map<RealtimeEvent, Set<StoredHandler>>()
+
+  return {
+    emit<TEvent extends RealtimeEvent>(
+      event: TEvent,
+      payload: RealtimeEventPayloads[TEvent],
+    ) {
+      const handlers = eventHandlers.get(event)
+      if (!handlers) return
+      for (const handler of handlers) {
+        handler(payload as never)
+      }
+    },
+    on<TEvent extends RealtimeEvent>(
+      event: TEvent,
+      handler: RealtimeEventHandler<TEvent>,
+    ): () => void {
+      let handlers = eventHandlers.get(event)
+      if (!handlers) {
+        handlers = new Set<StoredHandler>()
+        eventHandlers.set(event, handlers)
+      }
+      handlers.add(handler)
+
+      return () => {
+        handlers.delete(handler)
+      }
+    },
+  }
+}
diff --git a/packages/ai/src/realtime/index.ts b/packages/ai/src/realtime/index.ts
index 54a7a6439..07f378ab7 100644
--- a/packages/ai/src/realtime/index.ts
+++ b/packages/ai/src/realtime/index.ts
@@ -1,5 +1,7 @@
 import type { RealtimeToken, RealtimeTokenOptions } from './types'
 
+export { createRealtimeEventEmitter } from './event-emitter'
+
 // Re-export all types
 export type * from './types'
 
diff --git a/packages/ai/src/realtime/types.ts b/packages/ai/src/realtime/types.ts
index 0b58bce20..412f4ab3a 100644
--- a/packages/ai/src/realtime/types.ts
+++ b/packages/ai/src/realtime/types.ts
@@ -4,6 +4,8 @@ import type { AnyClientTool } from '../activities/chat/tools/tool-definition'
 // Token Types
 // ============================================================================
 
+import type { UsageInfo } from '../activities/chat/middleware'
+
 /**
  * Voice activity detection configuration
  */
@@ -24,6 +26,7 @@ export interface RealtimeToolConfig {
   name: string
   description: string
   inputSchema?: Record<string, any>
+  outputSchema?: Record<string, any>
 }
 
 /**
@@ -246,6 +249,8 @@ export type RealtimeEvent =
   | 'message_complete'
   | 'interrupted'
   | 'error'
+  | 'go_away' // Event that signals that the current connection will soon be terminated
+  | 'usage'
 
 /**
  * Event payloads for realtime events
@@ -263,6 +268,8 @@ export interface RealtimeEventPayloads {
   message_complete: { message: RealtimeMessage }
   interrupted: { messageId?: string }
   error: { error: Error }
+  go_away: { timeLeft?: string }
+  usage: UsageInfo
 }
 
 /**
@@ -355,6 +362,8 @@ export interface RealtimeConnection {
   // Session management
   /** Update session configuration */
   updateSession: (config: Partial<RealtimeSessionConfig>) => void
+  /** Update the ephemeral token (e.g. on refresh); provider may reconnect */
+  updateToken?: (token: RealtimeToken) => void
   /** Interrupt the current response */
   interrupt: () => void