@memberjunction/ai-realtime-client 6.2.0-edge.3 → 6.2.0-edge.4

package/dist/drivers/geminiRealtimeClient.d.ts

@@ -1,8 +1,9 @@
-import { ClientRealtimeSessionConfig } from '@memberjunction/ai';
+import { ClientRealtimeSessionConfig, type RealtimeClientTransport, type RealtimeResumeAttempt } from '@memberjunction/ai';
 import { type Blob as GeminiBlob, type Content, type FunctionResponse, type LiveConnectConfig, type LiveServerMessage } from '@google/genai';
 import { BaseRealtimeClient } from '../generic/baseRealtimeClient.js';
 import { IRealtimePcmPlayback, RealtimePcmPlayback } from '../audio/pcmPlayback.js';
 import { IPcmMicCapture } from '../audio/micCapture.js';
+import { type IAvatarVideoPlayout, type VideoPlayoutOptions } from '../media/videoPlayout.js';
 /**
  * The minimal subset of `@google/genai`'s `Session` this client depends on. Declaring the seam
  * as an interface (rather than the concrete SDK `Session`) lets unit tests inject a fully
@@ -35,17 +36,24 @@ export interface GeminiLiveClientSession {
 }
 /**
  * Arguments handed to {@link GeminiRealtimeClient.connectLiveSession}. Bundles the resolved
- * model + connect config (from the server-minted `SessionConfig`), the ephemeral token, and the
- * lifecycle callbacks so the seam owns the entire `live.connect` call and tests can substitute
- * it wholesale.
+ * model + connect config (from the server-minted `SessionConfig`), the ephemeral token (or a relay
+ * session's transport and relay URL), and the lifecycle callbacks so the seam owns the entire
+ * `live.connect` call and tests can substitute it wholesale.
  */
 export interface GeminiClientConnectArgs {
     /** The Gemini Live model id to open the session against. */
     Model: string;
     /** The server-built connect config (system instruction, tools, modalities, transcription). */
     Config: LiveConnectConfig;
-    /** The server-minted ephemeral auth token (used as the API key on a `v1alpha` client). */
+    /** The server-minted ephemeral auth token (used as the API key on a `v1alpha` client). Empty on a relay session. */
     EphemeralToken: string;
+    /** How the browser reaches the provider, as minted (`ClientRealtimeSessionConfig.Transport`); absent means direct. */
+    Transport?: RealtimeClientTransport;
+    /**
+     * A relay session's relay URL, as minted (`ClientRealtimeSessionConfig.RelayUrl`). It carries the relay's ticket:
+     * never log it or put it in an error message.
+     */
+    RelayUrl?: string;
     /** Invoked for every {@link LiveServerMessage} the server emits over the session. */
     OnMessage: (message: LiveServerMessage) => void;
     /** Invoked on a websocket-level error (fatal). */
@@ -95,21 +103,36 @@ export declare class GeminiPcmPlayback extends RealtimePcmPlayback {
  *   ({@link createMicCapture} seam) and streamed with `sendRealtimeInput`.
  * - **Audio out**: model PCM16 @ 24 kHz chunks scheduled through {@link GeminiPcmPlayback}
  *   ({@link createPlayback} seam); {@link IsAudioPlaying} is computed from the playout clock.
+ * - **Avatar out**: when the minted config grants an avatar and the host shows it (the outbound
+ *   video track is live), fragmented MP4 parts play through a {@link VideoPlayout}
+ *   ({@link CreateVideoPlayout} seam) handed to the host at connect, whose audio routes into the
+ *   PCM playback's graph; PCM follows the avatar's voice rule (see `GeminiAvatarOutput`). A host
+ *   that shows no avatar gets an audio-only session.
  * - **Event translation** (Gemini → contract): `inputTranscription` → User deltas/finals,
  *   `outputTranscription` → Assistant deltas/finals (accumulated like the OpenAI driver),
  *   `toolCall.functionCalls` → {@link OnToolCall} (callID→name cached for
  *   {@link SendToolResult}), `interrupted` → playback flush + `'listening'`,
  *   `turnComplete` → busy cleared + queued sends flushed, `usageMetadata` → {@link OnUsage}
- *   (per-turn prompt/response token deltas — see {@link handleUsageMetadata}).
+ *   (per-turn prompt/response token deltas with their modality split — see {@link handleUsageMetadata}).
+ *   An avatar's generated video seconds go to {@link OnUsage} in updates of their own
+ *   (`OutputTokenDetails.VideoSeconds`) at each turn boundary.
  * - **Busy mapping**: Gemini has no `response.created` frame, so `IsBusy` is set EAGERLY when
  *   this client triggers a response (text / narration / tool result) and on the first model
  *   output of a turn (audio part or output-transcription delta); cleared on `turnComplete`,
  *   and on a `toolCall` frame (the model has yielded the floor pending the tool result — so a
- *   slow `turnComplete` can never deadlock the queued result).
+ *   slow `turnComplete` can never deadlock the queued result). In an avatar session, video sets
+ *   it only while the model's answer is under way: Vertex AI streams the avatar's video between
+ *   answers too, and that idle video plays without marking the agent speaking or busy.
  * - **Collision safety**: ANY `sendClientContent` interrupts in-flight Gemini generation (per
  *   the Live API contract), so text / narration / context-note / tool-result sends issued
  *   while a turn is in flight are queued and flushed in order on `turnComplete` (the flush
  *   stops at the first send that starts a new response).
+ * - **Moving to a new connection**: Google ends a connection after about 10 minutes, announcing
+ *   it with `goAway`, and the session resumes on a new one with Google's handle
+ *   ({@link RealtimeSessionResumption}). A planned move waits until no turn is in progress
+ *   ({@link IsTurnOpen}). A connection is put to use only once Google confirms its setup
+ *   (`setupComplete`): input that reaches it earlier is dropped. During a move, sends queue and
+ *   the latest 2 s of mic audio are held; both go out on the new connection once it is ready.
  * - **Open-turn commit**: context notes ride as `turnComplete: false` client content, which
  *   tells the Live API MORE INPUT IS COMING — the server holds ALL generation (including the
  *   normally-automatic continuation after a tool response) until a `turnComplete: true`
@@ -136,15 +159,61 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     private micStream;
     private cameraStream;
     private micCapture;
-    private cameraCapture;
+    private cameraSampler;
     private playback;
+    /**
+     * The avatar half of the session: created at connect when the server granted an avatar and the host shows it (the
+     * outbound video track is live). `null` otherwise, and the session then plays model output as it always has.
+     */
+    private avatarOutput;
     private firstVideoSendTimestamp;
     private lastVideoSendTimestamp;
     protected videoFramesSent: number;
-    protected resumptionHandle: string | null;
-    private lastConnectArgs;
+    /**
+     * Moves the session to a new connection with Google's resumption handle: when Google
+     * announces the connection is ending (`goAway`, with the time left; on Vertex AI it came about
+     * 9 minutes into a connection, with 30 s left) and after an unexpected drop. A planned move
+     * waits until no turn is in progress ({@link IsTurnOpen}). Created per {@link Connect}.
+     */
+    private resumption;
+    /**
+     * Whether input can go out: the connection in use has confirmed its setup (`setupComplete`) and
+     * no move to a new connection is in progress. Google drops input that reaches a connection
+     * before its setup completes, and a connection being replaced resumes from a handle issued
+     * before the move, so what it receives never reaches the new one. While `false`, sends wait in
+     * {@link queuedSends} and microphone audio in {@link heldMicAudio}.
+     */
+    private connectionReady;
+    /** Microphone audio captured during a move, sent on the new connection once it is ready. */
+    private heldMicAudio;
+    /** Base64 characters in {@link heldMicAudio}, kept under {@link MAX_HELD_MIC_AUDIO_BASE64_CHARS}. */
+    private heldMicAudioChars;
+    /** See {@link IsTurnOpen}. */
+    private turnOpen;
+    /** A turn's `turnComplete` came while a tool call was pending: the turn ends once the last pending call's result goes out. */
+    private turnEndAwaitsToolResults;
+    /** Model, config and token of the current connection; a resume reuses them with the new handle. */
+    private connectTarget;
+    /** Last connection number handed out by {@link openConnection}. */
+    private issuedConnections;
+    /**
+     * Number of the connection in use. Callbacks from any other connection (one that was
+     * replaced, closed, or is still opening) are ignored, so a replaced socket's close can't end
+     * the session that replaced it. `0` while no connection is in use.
+     */
+    private currentConnection;
     /** Returns the latest session resumption handle reported by the server, if any. */
     get ResumptionHandle(): string | null;
+    /**
+     * Whether a turn is in progress. A turn opens at its first sign: the user's first transcribed words, a turn this
+     * client sends (typed text, a spoken update), or the model's output (a transcription delta, a thought, a tool call,
+     * an audio part, which in an avatar session must play as the voice, or, on an `interactionStatus` model, the
+     * `IN_PROGRESS` status; the video an avatar streams between turns never opens one). It closes at the turn's
+     * `turnComplete` (the true idle signal on an `interactionStatus` model) once no tool call is pending, or when the last
+     * pending call's result goes out after that; and at a resume. The session moves to a new connection only between
+     * turns.
+     */
+    get IsTurnOpen(): boolean;
     /** Returns the count of video frames successfully sent over the established video track. */
     get VideoFramesSent(): number;
     /**
@@ -170,6 +239,8 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     private pendingUserText;
     /** Accumulates in-flight thought text deltas until finalized on turn completion. */
     private pendingThoughtText;
+    /** MIME types of model output this session dropped, so each is reported once. */
+    private droppedOutputTypes;
     /** True while a model turn is in flight; gates (queues) client-triggered sends. */
     private responseActive;
     /** The kind of the turn currently in flight; stamped at send time, reset on turnComplete. */
@@ -198,20 +269,74 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * leaves `'speaking'` (no emission) until the result reply's first output re-asserts it.
      */
     private currentState;
-    /**
-     * Opens the client-direct Gemini Live session: creates the playout engine, connects with
-     * the ephemeral token + the server-built `SessionConfig` (`{ model, config }` — the same
-     * values the server LOCKED into the token, so tampering is ignored by the API), then wires
-     * the mic-capture worklet. Reports `'listening'` once audio is flowing.
-     */
     /**
      * Opens the client-direct Gemini Live session: creates the playout engine, connects with
      * the ephemeral token + the server-built `SessionConfig` (`{ model, config }` — the same
      * values the server LOCKED into the token, so tampering is ignored by the API), negotiates
      * tracks, then wires the mic-capture worklet and optional video capture.
-     * Reports `'listening'` once audio is flowing.
+     * Reports `'connected'` once Google confirms the session's setup (`setupComplete`): input
+     * sent before that is dropped, so nothing goes out on the connection, and the microphone
+     * does not start, until then. Reports `'listening'` once audio is flowing.
+     *
+     * When the server granted an avatar (the minted `avatar` block) and the host shows it (the
+     * outbound video track is live), the avatar's video goes to the host once the connection is
+     * open. When the host doesn't show it, the session connects audio only.
+     *
+     * @throws When the connection closes or fails before Google confirms its setup, or no
+     *   confirmation comes in time (see `RealtimeConnectionSetup`).
      */
     Connect(config: ClientRealtimeSessionConfig, micStream: MediaStream, cameraStream?: MediaStream): Promise<void>;
+    /** Takes the streams for a new connect and clears what an earlier one left behind. */
+    private resetForConnect;
+    /** No connection ready, no audio held, no turn open: the state of a session before its first connection. */
+    private resetConnectionState;
+    /**
+     * Opens the session's first connection and puts it to use once Google confirms its setup.
+     *
+     * @returns `false` when the consumer disconnected while the setup was in flight; the connection is then closed, and a
+     *   setup failure after the disconnect is not reported.
+     */
+    private openFirstConnection;
+    /**
+     * Negotiates tracks. Video capability and its frame-rate ceiling are PER-MODEL DATA, minted
+     * from the provider's profile table (GeminiLiveModelProfile.SupportsInboundVideo /
+     * .MaxInboundVideoRate) and carried in the session config. Deriving either from the model
+     * id would put a second answer to the same question in a second place: the two agreed only
+     * because the model names happened to line up, and the next model to break that pattern
+     * would diverge silently. A granted avatar adds an outbound video track when this browser
+     * can play it.
+     */
+    private negotiateSessionTracks;
+    /** The outbound video track a granted avatar offers, or `null` when this browser can't play its type through MSE. */
+    private static avatarTrackFor;
+    /**
+     * Sets up the avatar the server granted, when the host shows it (the outbound video track is
+     * live). Otherwise the session runs audio only: the config sent at connect asks for audio and
+     * no avatar, and one line says why. Returns the config to connect with.
+     */
+    private prepareAvatar;
+    /**
+     * The one line for a granted avatar this session won't show, in the server driver's format: `browser` when the host
+     * asked for the agent's video and this browser can't play it, `host` when the host asked for none.
+     */
+    private avatarDowngradeMessage;
+    /** The connect config of a session whose avatar won't show: audio out, and no avatar. */
+    private static withoutAvatar;
+    /** Starts the microphone capture, the camera passed to `Connect` when inbound video is live, and both audio meters. */
+    private startLocalCapture;
+    /**
+     * Stops the avatar's video and releases its element; the session then has no avatar. The video it generated and
+     * did not yet report is emitted first.
+     */
+    private disposeAvatarOutput;
+    /**
+     * Samples the camera passed to {@link Connect} at the rate the video track negotiated and feeds it to
+     * the session's {@link VideoSourceArbiter} as a `'camera'` source. The arbiter stays the only writer of
+     * inbound video, and it tells the model when it switches to the camera.
+     */
+    private startConnectCamera;
+    /** Stops sampling the `Connect` camera and removes it from the arbiter. Does not stop its tracks. */
+    private stopConnectCamera;
     /**
      * Tears down the session, mic capture, mic tracks, camera capture, and playout engine,
      * resets the response state machine, and emits a final `'closed'` (unless already `'error'`).
@@ -236,19 +361,26 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     /**
      * Streams one base64 image frame over the established inbound video track.
      *
-     * Enforces a 750ms minimum inter-frame spacing to serve as a backstop with deliberate jitter
-     * headroom for 1 fps (1000ms) pacers (such as `ChannelInboundVideoBridge`'s `setInterval`,
-     * `frameCapture`, and channel-level gates like `OnScreencastFrame`'s 1000ms pacer). Upstream
-     * cadence generators and channel gates are the primary enforcers of the nominal 1 fps ceiling,
-     * while this 750ms gate absorbs event loop and async dispatch jitter without dropping intended
-     * 1Hz frames, while preventing any unpaced callers from bursting above 1.33 fps.
+     * Enforces a minimum inter-frame spacing as a backstop with deliberate jitter headroom for the
+     * upstream pacers (the source arbiter, `ChannelInboundVideoBridge`, `frameCapture`, channel-level
+     * gates such as `OnScreencastFrame`). The spacing is derived from the rate the track NEGOTIATED
+     * ({@link MinVideoFrameSpacingMs} of {@link BaseRealtimeClient.InboundVideoRate}), so it follows the
+     * model's profile rather than a constant: at the 1 fps every Live model accepts today it is the
+     * 750 ms gate this driver has always applied, and a faster model needs no change here. Upstream
+     * generators are the primary enforcers of the nominal rate; this gate absorbs event-loop and async
+     * dispatch jitter without dropping intended frames, while preventing an unpaced caller from bursting.
+     *
+     * Gemini accepts ONE inbound video stream, so `sourceId` is ignored: choosing which source feeds that
+     * stream is the arbiter's job, and by the time a frame arrives here the choice is made.
      *
      * If inbound video is not established, returns `false` without error or frame sends (fallback).
+     * A frame that comes while no connection is ready (before Google confirms the setup, or while
+     * the session moves to a new connection) is dropped too: the source sends the next one at the track's rate.
      *
-     * @returns `true` if the frame was dispatched to the session; `false` if dropped (throttled
-     *   or track unestablished).
+     * @returns `true` if the frame was dispatched to the session; `false` if dropped (throttled,
+     *   track unestablished, or no connection ready).
      */
-    SendVideoFrame(base64Image: string, mimeType?: string): boolean;
+    SendVideoFrame(base64Image: string, mimeType?: string, _sourceId?: string): boolean;
     /**
      * @inheritdoc
      *
@@ -259,7 +391,7 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * by a cancel). Server-side, the next client content sent naturally interrupts any
      * residual generation per the Live API contract. The interrupted turn's accumulated
      * transcript is kept — the provider's trailing frames finalize what WAS spoken. No-op
-     * when nothing is active.
+     * when nothing is active. An avatar's video stops with the voice.
      */
     CancelActiveResponse(): void;
     /**
@@ -304,6 +436,8 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * client driver).
      */
     SetMuted(muted: boolean): void;
+    /** Rebinds the PCM capture and the input meter to the stream's current track (obligation #10); the socket stays open. */
+    ReplaceMicrophone(micStream: MediaStream): Promise<void>;
     /** @inheritdoc */
     get IsBusy(): boolean;
     /**
@@ -311,7 +445,10 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      *
      * Computed directly from the playout engine's playhead clock — this client OWNS the output
      * buffer (no WebRTC playback events exist on Gemini), so "audibly playing" is precisely
-     * "scheduled audio extends beyond the audio context's current time".
+     * "scheduled audio extends beyond the audio context's current time". In an avatar session
+     * the avatar's video counts too, while some of an answer's media is still ahead of its
+     * playhead: its MP4 usually carries the voice. The idle video that follows an answer does
+     * not count.
      */
     get IsAudioPlaying(): boolean;
     /**
@@ -331,6 +468,15 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     protected createMicCapture(micStream: MediaStream, onPcmChunk: (base64Pcm16: string) => void): Promise<IGeminiMicCapture>;
     /** Creation seam for the playout engine. Production returns {@link GeminiPcmPlayback}. */
     protected createPlayback(): IGeminiAudioPlayback;
+    /**
+     * Creation seam for the avatar's video player, called at connect when the server granted an
+     * avatar and the host shows it. Production returns {@link VideoPlayout} (Media Source
+     * Extensions); unit tests return a fake.
+     *
+     * @param options The type the grant names, whether the video carries the voice, and the hook
+     *   that routes the element's audio into the PCM playback's Web Audio graph.
+     */
+    protected CreateVideoPlayout(options: VideoPlayoutOptions): IAvatarVideoPlayout;
     /**
      * Extracts the model + Live connect config from the server-minted `SessionConfig`
      * (shaped `{ model, config }` by the server's `GeminiRealtime.CreateClientSession`).
@@ -338,11 +484,36 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * server locked the real config into the token, so the session still behaves correctly.
      */
     private parseSessionConfig;
-    /** Streams one base64 PCM16 mic chunk to the model (no-op once the session is gone, closed, or in error). */
+    /** The tracks the runtime asks the session for (`requestedTracks`); `undefined` when it sent no list. */
+    private static readRequestedTracks;
+    /**
+     * The avatar the server granted: the minted `avatar` block (`{ output: true, encoding, audioMuxed }`), which the
+     * server writes only when the session renders one. `audioMuxed` defaults to true, as the server's profile does.
+     */
+    private static readAvatarGrant;
+    /**
+     * Streams one base64 PCM16 mic chunk to the model (no-op once the session is gone, closed, or in error). During a
+     * move to a new connection the chunk is held instead, and goes out on the new connection once it is ready.
+     */
     private sendMicChunk;
-    /** Surfaces a fatal websocket error and marks the session unusable. */
+    /** Sends one base64 PCM16 mic chunk on `session`; a failed send is logged, not thrown. */
+    private sendAudio;
+    /** Holds a mic chunk during a move, keeping the latest {@link HELD_MIC_AUDIO_SECONDS} seconds; older audio goes first. */
+    private holdMicChunk;
+    /** Sends the mic audio held during a move on the connection now in use, oldest first. */
+    private sendHeldMicAudio;
+    /**
+     * Surfaces a fatal websocket error and marks the session unusable. When the session can be
+     * resumed, the error is only logged: a websocket `error` is always followed by a `close`,
+     * and {@link handleTransportClose} resumes from there.
+     */
     private handleTransportError;
-    /** Reflects a provider-side close (unless the session already ended in error). */
+    /**
+     * Handles a close of the current connection that the consumer did not ask for. MJAPI's relay
+     * closing at the session's time limit ends the call with a `time-limit` error. Otherwise, when
+     * Google issued a resumption handle, the session reconnects with it; else the close ends the
+     * session, as an error when it was abnormal.
+     */
     private handleTransportClose;
     /**
      * Entry point for every inbound {@link LiveServerMessage}; fans out to per-concern
@@ -350,9 +521,52 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      */
     private handleServerMessage;
     /**
-     * Resumes the live session using a previously captured session resumption handle (F7).
-     */
-    protected resumeSession(handle: string): Promise<void>;
+     * Opens a replacement connection that resumes the session from `handle`, switches to it once
+     * Google confirms its setup, and closes the old one. Until then the old connection stays in
+     * use, so what it still sends (the rest of a turn the deadline cut, its usage) is handled.
+     * Mic capture and playout carry over untouched. Rejects when the connection can't be opened or
+     * its setup fails, so {@link RealtimeSessionResumption} can retry.
+     *
+     * The resume reuses the session's ephemeral token, which Google accepts until the token's
+     * `expireTime` (the server driver mints 30 minutes). After that every attempt fails and the
+     * session ends with a fatal error.
+     *
+     * @param handle The resumption handle Google issued.
+     * @param attempt Marks the attempt abandoned after a timeout or a consumer close; a
+     *                connection that opens after that is closed instead of used.
+     */
+    protected resumeSession(handle: string, attempt: RealtimeResumeAttempt): Promise<void>;
+    /**
+     * Opens a connection through {@link connectLiveSession}. Its callbacks act only while it is the
+     * connection in use, so events from one that was replaced, closed, or is still opening are
+     * dropped; its `setupComplete`, and a close or error before it, settle its {@link GeminiOpenedConnection.Setup}
+     * whether or not it is in use yet. It becomes the connection in use through {@link useConnection},
+     * which lets the old connection keep delivering events while a planned move is in progress.
+     */
+    private openConnection;
+    /** Waits for Google to confirm a new connection's setup. On failure the connection is closed and the error rethrown. */
+    private static awaitSetup;
+    /** What a websocket error event says went wrong. */
+    private static transportErrorDetail;
+    /** Makes an opened connection the one in use. */
+    private useConnection;
+    /**
+     * Builds the resumption helper for a newly connected session; see {@link resumption}. From the
+     * moment a move starts, input waits for the new connection ({@link connectionReady}).
+     */
+    private createResumption;
+    /**
+     * The session continues on a new connection, whose setup Google has confirmed. A turn cut off
+     * by a drop or the deadline never completes there, so the turn state is reset (its partial
+     * transcripts are emitted as final). The mic audio held during the move goes out, then the
+     * sends queued behind it. An avatar's video plays out what arrived of that turn and holds its
+     * last frame.
+     */
+    private handleResumed;
+    /** Every resume attempt failed: the session ends with a fatal error. */
+    private handleResumeFailed;
+    /** Closes a socket the session no longer uses; it may already be closed. */
+    private static closeQuietly;
     /**
      * Inspects inbound frames for the untyped `interaction_status` / `interactionStatus` wire field
      * documented for Gemini Live Extended Thinking (V3). Narrowed via null-safe object/string helpers.
@@ -369,7 +583,22 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * the server-bridged `GeminiRealtime` driver forwards the same payload to `IRealtimeSession.OnUsage`.
      */
     private handleUsageMetadata;
-    /** Translates one {@link LiveServerContent} frame in provider-documented signal order. */
+    /**
+     * Gemini's per-modality token counts (`promptTokensDetails` or `responseTokensDetails`) as a detail block: TEXT,
+     * AUDIO, IMAGE and VIDEO. `undefined` when Gemini sent no count for a modality it names.
+     */
+    private static modalityTokens;
+    /**
+     * Emits the avatar video generated since the last emission as an update of its own
+     * (`OutputTokenDetails.VideoSeconds`, an amount): called where a turn's counting ends (generation complete,
+     * turn complete, resumed; an interrupted turn ends at its turn complete) and before the avatar output is
+     * disposed, so every second is emitted once, whenever Google's `usageMetadata` arrives.
+     */
+    private emitAvatarVideoSeconds;
+    /**
+     * Translates one {@link LiveServerContent} frame in provider-documented signal order. What the frame carries opens
+     * the turn before its `turnComplete` ends it.
+     */
     private handleServerContent;
     /**
      * generationComplete: indicates the model has finished generating all tokens for the turn.
@@ -377,6 +606,8 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      *
      * Per Reviewer Item 20: Draining the queue happens on turnComplete or true IDLE, not prematurely
      * on generationComplete. We set responseActive = false so busy state reflects token completion.
+     * An avatar's video gets its end of turn here: playback runs to the true end and holds the
+     * last frame.
      */
     private handleGenerationComplete;
     /**
@@ -385,11 +616,19 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
      * client's audio queue), surface the TRUE barge-in to the host (Gemini only emits
      * `interrupted` when user input actually cut off in-flight generation — no extra gating
      * needed), and give the floor back. The interrupted turn's accumulated transcript is
-     * kept — the following `turnComplete` finalizes what WAS spoken.
+     * kept — the following `turnComplete` finalizes what WAS spoken. In an avatar session the
+     * video stops too, and the turn's late parts are dropped until its `turnComplete`.
      */
     private handleInterruption;
-    /** Decodes inline model-audio parts (base64 PCM16 @ 24 kHz) into the playout queue. */
-    private handleModelAudio;
+    /**
+     * Plays inline model parts. In an avatar session the avatar output routes each part to the
+     * video, to the PCM playback or nowhere; only the answer's parts mark generation started
+     * (and the turn open): the idle video between answers plays without making the agent
+     * speaking or busy. Otherwise base64 PCM16 @ 24 kHz parts go to the playout queue.
+     */
+    private handleModelMedia;
+    /** Reports each MIME type of dropped model output once per session, not once per part. */
+    private reportDroppedOutput;
     /**
      * Extracts thought parts (`part.thought === true`) from model turns and emits them
      * as narration transcript deltas (`Kind: 'narration'`). Thought summaries are reasoning
@@ -424,23 +663,23 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     private handleToolCallFrame;
     /**
      * Turn boundary: finalize any un-finished assistant transcript.
-     * Under 'turnComplete' idle signal, release the busy lock, reset response kind,
-     * drain queued sends, and return the floor to the user.
+     * Under 'turnComplete' idle signal, end the turn (see {@link IsTurnOpen}), release the busy
+     * lock, reset response kind, drain queued sends, and return the floor to the user.
      * Under 'interactionStatus' (Extended Thinking), turnComplete does NOT indicate idle:
-     * background reasoning or async tool calls may still be in flight, so the busy lock
+     * background reasoning or async tool calls may still be in flight, so the turn, the busy lock
      * and queued sends remain held until the true IDLE signal lands.
      */
     private handleTurnComplete;
     /**
      * Reached when the server emits true IDLE (interactionStatus) or the safety backstop fires.
-     * Releases busy state, commits any deferred open client turns without cutting off generation,
-     * drains queued sends, and returns the floor.
+     * Ends the turn (see {@link IsTurnOpen}), releases busy state, commits any deferred open client
+     * turns without cutting off generation, drains queued sends, and returns the floor.
      */
     private handleIdleTerminal;
     /**
-     * First model output of a turn (audio part or transcription delta): the user's turn is
-     * over (finalize their pending transcript), the model is busy, and the client is audibly /
-     * imminently `'speaking'`.
+     * First model output of a turn (audio part, transcription delta, or a part of an avatar's
+     * answer): the user's turn is over (finalize their pending transcript), the model is busy,
+     * and the client is audibly / imminently `'speaking'`.
      */
     private markGenerationStarted;
     /** Emits the accumulated user turn as final (if non-empty) and clears the accumulator. */
@@ -449,16 +688,43 @@ export declare class GeminiRealtimeClient extends BaseRealtimeClient {
     private finalizeAssistantTranscript;
     /** Emits the accumulated thought turn as final (if non-empty) with Kind: 'narration' and IsThought: true. */
     private finalizeThoughtTranscript;
+    /**
+     * Whether a server content message is a sign of a turn: the user's or the model's transcribed
+     * words, a thought, or (in a session without an avatar) the model's audio. An avatar's video
+     * never is: Vertex AI streams it between turns too.
+     */
+    private contentOpensTurn;
+    /**
+     * Whether a model part is a sign of a turn: a thought, or audio (as this client plays it) in a session without an
+     * avatar. In an avatar session, a voice part opens the turn once it plays ({@link handleModelMedia}).
+     */
+    private partOpensTurn;
+    /** Whether a transcription frame carries words (whitespace alone does not count). */
+    private static hasText;
+    /** A turn started or continued: a planned move waits until it ends. */
+    private markTurnOpen;
+    /** The turn's `turnComplete` (or true idle): it ends now, or once the results of the tool calls still pending go out. */
+    private endTurnUnlessToolCallPending;
+    /** A tool result went out: a turn whose `turnComplete` waited on the pending calls ends once none is left. */
+    private endTurnIfToolResultsIn;
+    /** The turn is over: a planned move happens at the next resumable handle Google issues. */
+    private endTurn;
     /**
      * Runs a send immediately when no turn is in flight; otherwise queues it for the next
      * `turnComplete`. This is Gemini's equivalent of the OpenAI driver's
      * queue-behind-active-response rule — stricter here because ANY client content interrupts
-     * in-flight generation on the Live API.
+     * in-flight generation on the Live API. Every send also waits while no connection is ready
+     * ({@link connectionReady}): during a move it goes out on the new connection.
+     *
+     * @param send The send.
+     * @param waitsForTurn Whether the send waits for a turn in flight (`false` for a non-blocking
+     *   tool result, which goes out while the model talks).
      */
     private enqueueOrRun;
     /**
      * Drains queued sends in order on a turn boundary, stopping as soon as one starts a new
-     * turn (sets {@link responseActive}) — the rest wait for that turn's completion.
+     * turn (sets {@link responseActive}) — the rest wait for that turn's completion. Nothing
+     * drains while no connection is ready: {@link handleResumed} drains onto the new one.
      */
     private flushQueuedSends;
     /**

package/dist/drivers/geminiRealtimeClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geminiRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/geminiRealtimeClient.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"geminiRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/geminiRealtimeClient.ts"],"names":[],"mappings":"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"}