@theoremjs/react 0.0.0-stage → 0.3.0

package/client/ink-waveform.d.ts

@@ -0,0 +1,17 @@
+export declare const INK_WAVE_BAR_COUNT = 21;
+export declare const INK_WAVE_HERO_BAR_COUNT = 45;
+/** Per-bar phase offsets — stable undulation, not a fixed bell curve. */
+export declare function inkWavePhases(count: number): number[];
+export type InkWaveStatus = 'disconnected' | 'connecting' | 'connected' | 'ready' | 'listening' | 'speaking' | 'working' | 'error';
+export type InkWaveDriver = 'idle' | 'input' | 'output' | 'tool' | 'working' | 'connecting';
+export declare function inkWaveDriver(status: InkWaveStatus, toolActive: boolean, inputLevel: number, outputLevel: number, frozen?: boolean): InkWaveDriver;
+export declare function computeInkBarTargets(args: {
+    phases: readonly number[];
+    timeMs: number;
+    driver: InkWaveDriver;
+    inputLevel: number;
+    outputLevel: number;
+    frozen?: boolean;
+}): number[];
+/** Smooth toward targets each animation frame (orchid ease feel). */
+export declare function stepInkBarHeights(current: number[], targets: number[], alpha?: number): number[];

package/client/ink-waveform.js

@@ -0,0 +1,69 @@
+export const INK_WAVE_BAR_COUNT = 21;
+export const INK_WAVE_HERO_BAR_COUNT = 45;
+const LEVEL_FLOOR = 0.02;
+/** Per-bar phase offsets — stable undulation, not a fixed bell curve. */
+export function inkWavePhases(count) {
+    return Array.from({ length: count }, (_, i) => i * 0.73 + Math.sin(i * 1.17) * 0.4);
+}
+export function inkWaveDriver(status, toolActive, inputLevel, outputLevel, frozen = false) {
+    if (frozen)
+        return 'idle';
+    if (status === 'disconnected' || status === 'error')
+        return 'idle';
+    if (status === 'connecting')
+        return 'connecting';
+    if (toolActive)
+        return 'tool';
+    if (status === 'speaking' || outputLevel > LEVEL_FLOOR)
+        return 'output';
+    if (inputLevel > LEVEL_FLOOR)
+        return 'input';
+    if (status === 'working')
+        return 'working';
+    if (status === 'listening' || status === 'ready')
+        return 'idle';
+    return 'idle';
+}
+export function computeInkBarTargets(args) {
+    const t = args.timeMs * 0.001;
+    if (args.frozen) {
+        return args.phases.map((phase, index) => {
+            const silhouette = 0.22 + 0.55 * (0.5 + 0.5 * Math.sin(phase * 1.7 + index * 0.41));
+            return Math.min(0.82, Math.max(0.1, silhouette));
+        });
+    }
+    const input = args.inputLevel;
+    const output = args.outputLevel;
+    let master;
+    switch (args.driver) {
+        case 'output':
+            master = 0.18 + output * 0.95;
+            break;
+        case 'input':
+            master = 0.16 + input * 0.96;
+            break;
+        case 'tool':
+            master = 0.28 + 0.18 * Math.sin(t * 5.2) + Math.max(output, input) * 0.45;
+            break;
+        case 'working':
+            // Quiet, slow breathing: the server is reasoning, nobody is speaking.
+            master = 0.16 + 0.08 * Math.sin(t * 2.2) + Math.max(output, input) * 0.45;
+            break;
+        case 'connecting':
+            master = 0.14 + 0.1 * Math.sin(t * 3.1);
+            break;
+        default:
+            master = 0.08 + 0.04 * Math.sin(t * 1.4);
+            break;
+    }
+    return args.phases.map((phase, index) => {
+        const wobble = 0.72 + 0.28 * Math.sin(t * 3.4 + phase);
+        const ripple = 0.68 + 0.32 * Math.sin(t * 5.3 + index * 0.62);
+        const height = master * wobble * ripple;
+        return Math.min(1, Math.max(0.06, height));
+    });
+}
+/** Smooth toward targets each animation frame (orchid ease feel). */
+export function stepInkBarHeights(current, targets, alpha = 0.14) {
+    return current.map((value, index) => value + (targets[index] - value) * alpha);
+}

package/client/live/apply-live-turn-tool-event.d.ts

@@ -0,0 +1,14 @@
+import type { TurnEvent } from '@theoremjs/agents';
+type LiveToolEventArgs = {
+    /** The call whose gate the user is looking at, if one is open. */
+    gateCallId: string | undefined;
+    /** Close the open gate without an answer: its call is gone. */
+    withdrawGate: () => void;
+    clearInterim: () => void;
+    clearActiveTool: () => void;
+    reportFailure: (err: unknown) => void;
+    setActiveTool: (name: string) => void;
+};
+export type { LiveToolEventArgs };
+/** Apply a live turn event to active-tool / caption / error state. */
+export declare function applyLiveTurnToolEvent(event: TurnEvent, args: LiveToolEventArgs): void;

package/client/live/apply-live-turn-tool-event.js

@@ -0,0 +1,39 @@
+import { TheoremStreamError } from "../transport.js";
+/**
+ * A failed tool step as the host reported it: the user reads its wording (else
+ * the lexicon's for its kind); the model's `message` stays builder detail.
+ */
+function toolStepFailure(failure) {
+    return new TheoremStreamError(failure.kind, failure.error, failure.message);
+}
+function clearToolUnlessGated(args) {
+    if (args.gateCallId === undefined)
+        args.clearActiveTool();
+}
+function applyToolPhase(tool, args) {
+    if (tool.phase === 'cancel' && tool.callId === args.gateCallId) {
+        args.withdrawGate();
+        args.clearActiveTool();
+        return;
+    }
+    if (tool.phase === 'cancel' || tool.phase === 'complete') {
+        clearToolUnlessGated(args);
+        return;
+    }
+    if (tool.phase === 'error') {
+        args.reportFailure(toolStepFailure(tool.failure));
+        clearToolUnlessGated(args);
+        return;
+    }
+    args.setActiveTool(tool.name);
+}
+/** Apply a live turn event to active-tool / caption / error state. */
+export function applyLiveTurnToolEvent(event, args) {
+    if (event.type === 'done') {
+        args.clearInterim();
+        clearToolUnlessGated(args);
+        return;
+    }
+    if (event.type === 'tool')
+        applyToolPhase(event.tool, args);
+}

package/client/live/live-captions.d.ts

@@ -0,0 +1,23 @@
+export type LiveCaptionTurn = {
+    id: string;
+    role: 'user' | 'agent';
+    text: string;
+};
+export type LiveCaptionState = {
+    turns: LiveCaptionTurn[];
+    interimUser: string;
+    interimAgent: string;
+};
+export type ApplyLiveTranscriptOptions = {
+    /** Commit as a new turn even when the last turn shares the same role (explicit text send). */
+    forceNew?: boolean;
+};
+export declare function emptyLiveCaptionState(): LiveCaptionState;
+/**
+ * Fold streaming ASR deltas into turn-by-turn caption lines.
+ * Final chunks for the same role append to the open turn; role switches start a new turn.
+ */
+export declare function applyLiveTranscript(state: LiveCaptionState, text: string, isUser: boolean, interim?: boolean, options?: ApplyLiveTranscriptOptions): LiveCaptionState;
+/** Clear streaming partials when a live turn completes or is interrupted. */
+export declare function clearLiveCaptionInterim(state: LiveCaptionState): LiveCaptionState;
+export declare function latestLiveCaptionTurnId(state: LiveCaptionState): string | null;

package/client/live/live-captions.js

@@ -0,0 +1,70 @@
+export function emptyLiveCaptionState() {
+    return { turns: [], interimUser: '', interimAgent: '' };
+}
+function mergeInterimWithFinal(interim, final) {
+    if (!interim)
+        return final;
+    if (!final)
+        return interim;
+    if (final.startsWith(interim) || interim.startsWith(final)) {
+        return final.length >= interim.length ? final : interim;
+    }
+    return appendTurnText(interim, final);
+}
+function appendTurnText(existing, chunk) {
+    if (!existing)
+        return chunk;
+    if (!chunk)
+        return existing;
+    const needsSpace = !existing.endsWith(' ') &&
+        !chunk.startsWith(' ') &&
+        !/^\s/.test(chunk) &&
+        !/^[\s.,!?;:]/.test(chunk);
+    return needsSpace ? `${existing} ${chunk}` : `${existing}${chunk}`;
+}
+function nextTurnId(state) {
+    return `${String(Date.now())}-${String(state.turns.length)}`;
+}
+/**
+ * Fold streaming ASR deltas into turn-by-turn caption lines.
+ * Final chunks for the same role append to the open turn; role switches start a new turn.
+ */
+export function applyLiveTranscript(state, text, isUser, interim, options) {
+    if (!text)
+        return state;
+    if (interim) {
+        return isUser ? { ...state, interimUser: text } : { ...state, interimAgent: text };
+    }
+    const role = isUser ? 'user' : 'agent';
+    const turns = [...state.turns];
+    const last = turns.at(-1);
+    const interimText = isUser ? state.interimUser : state.interimAgent;
+    if (!options?.forceNew && last?.role === role) {
+        turns[turns.length - 1] = {
+            ...last,
+            text: appendTurnText(last.text, text),
+        };
+    }
+    else {
+        const committed = options?.forceNew ? text : mergeInterimWithFinal(interimText, text);
+        turns.push({
+            id: nextTurnId(state),
+            role,
+            text: committed,
+        });
+    }
+    return {
+        turns,
+        interimUser: isUser ? '' : state.interimUser,
+        interimAgent: isUser ? state.interimAgent : '',
+    };
+}
+/** Clear streaming partials when a live turn completes or is interrupted. */
+export function clearLiveCaptionInterim(state) {
+    if (!state.interimUser && !state.interimAgent)
+        return state;
+    return { ...state, interimUser: '', interimAgent: '' };
+}
+export function latestLiveCaptionTurnId(state) {
+    return state.turns.at(-1)?.id ?? null;
+}

package/client/live/live-mic-forward.d.ts

@@ -0,0 +1,29 @@
+import type { ToolCallEvent, TurnEventOf } from '@theoremjs/agents';
+/** Whether a mic frame should be sent upstream given mute / socket / barge-in gates. */
+export declare function shouldForwardMicFrame(args: {
+    isMuted: boolean;
+    socketOpen: boolean;
+    modelPlaying: boolean;
+    rms: number;
+    bargeInRmsWhileSpeaking: number;
+}): boolean;
+/** Classify live evidence transcription into a UI transcript callback payload. */
+export declare function liveTranscriptFromEvidence(event: TurnEventOf<'evidence'>): {
+    text: string;
+    isUser: boolean;
+    interim: boolean;
+} | null;
+export type LiveToolCallDraft = {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+};
+/**
+ * Fold a tool turn event into cancelled-id / runnable-call lists. The model's
+ * call is runnable; a failure in the same batch (a name or arguments the
+ * provider could not use) is not: the session answered the model with it.
+ */
+export declare function applyLiveToolTurnEvent(tool: ToolCallEvent, accum: {
+    cancelledToolIds: Set<string>;
+    toolCalls: LiveToolCallDraft[];
+}): void;

package/client/live/live-mic-forward.js

@@ -0,0 +1,37 @@
+/** Whether a mic frame should be sent upstream given mute / socket / barge-in gates. */
+export function shouldForwardMicFrame(args) {
+    if (args.isMuted || !args.socketOpen)
+        return false;
+    if (args.modelPlaying && args.rms < args.bargeInRmsWhileSpeaking)
+        return false;
+    return true;
+}
+/** Classify live evidence transcription into a UI transcript callback payload. */
+export function liveTranscriptFromEvidence(event) {
+    const { evidence, text } = event;
+    if (!text)
+        return null;
+    if (evidence.kind !== 'input_transcription' && evidence.kind !== 'output_transcription')
+        return null;
+    return { text, isUser: evidence.kind === 'input_transcription', interim: evidence.interim === true };
+}
+/**
+ * Fold a tool turn event into cancelled-id / runnable-call lists. The model's
+ * call is runnable; a failure in the same batch (a name or arguments the
+ * provider could not use) is not: the session answered the model with it.
+ */
+export function applyLiveToolTurnEvent(tool, accum) {
+    if (tool.phase === undefined) {
+        accum.toolCalls.push({ id: tool.callId, name: tool.name, arguments: tool.arguments });
+        return;
+    }
+    if (tool.phase === 'cancel') {
+        accum.cancelledToolIds.add(tool.callId);
+        return;
+    }
+    if (tool.phase !== 'error')
+        return;
+    const failed = accum.toolCalls.findIndex((draft) => draft.id === tool.callId);
+    if (failed !== -1)
+        accum.toolCalls.splice(failed, 1);
+}

package/client/live/live-state.d.ts

@@ -0,0 +1,11 @@
+export type LiveSessionStatus = 'disconnected' | 'connecting' | 'ready' | 'listening' | 'speaking' | 'working' | 'error';
+export type LiveConnectPhase = 'socket' | 'microphone';
+/** What a live call is doing, for its status line; the UI words it. */
+export type LiveState = 'calling_tool' | 'connecting' | 'requesting_mic' | 'speaking' | 'connected' | 'muted' | 'listening' | 'error' | 'ended';
+export declare function liveState(args: {
+    status: LiveSessionStatus;
+    connectPhase: LiveConnectPhase | null;
+    toolName: string | null;
+    isMuted: boolean;
+    voiceEnabled?: boolean;
+}): LiveState;

package/client/live/live-state.js

@@ -0,0 +1,20 @@
+export function liveState(args) {
+    if (args.toolName)
+        return 'calling_tool';
+    if (args.connectPhase === 'socket')
+        return 'connecting';
+    if (args.connectPhase === 'microphone')
+        return 'requesting_mic';
+    if (args.status === 'speaking')
+        return 'speaking';
+    if (args.status === 'listening' || args.status === 'ready') {
+        if (args.voiceEnabled === false)
+            return 'connected';
+        return args.isMuted ? 'muted' : 'listening';
+    }
+    if (args.status === 'connecting')
+        return 'connecting';
+    if (args.status === 'error')
+        return 'error';
+    return 'ended';
+}

package/client/live/live-tool.d.ts

@@ -0,0 +1,11 @@
+import type { ToolGate } from '@theoremjs/agents/kernel';
+import type { ToolGateResolution } from '../tool-resume.ts';
+/** A gate the user is asked to answer, for the model's call `callId`. */
+export type LiveToolGatePrompt = {
+    callId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    gate: ToolGate;
+};
+/** The user's answer to a live gate, or `withdrawn`: the model cancelled the call, so nothing is asked. */
+export type LiveGateAnswer = ToolGateResolution | 'withdrawn';

package/client/live/live-tool.js

@@ -0,0 +1 @@
+export {};

package/client/live/live-video.d.ts

@@ -0,0 +1,10 @@
+export type LiveFacingMode = 'user' | 'environment';
+export type LiveVideoCapture = {
+    stop: () => void;
+    readonly video: HTMLVideoElement;
+    facingMode: () => LiveFacingMode;
+    flip: () => Promise<LiveFacingMode>;
+};
+export declare function startLiveVideoCapture(onFrame: (base64: string) => void, options?: {
+    facingMode?: LiveFacingMode;
+}): Promise<LiveVideoCapture>;

package/client/live/live-video.js

@@ -0,0 +1,71 @@
+import { TheoremError } from '@theoremjs/agents';
+const JPEG_QUALITY = 0.62;
+const FRAME_INTERVAL_MS = 400;
+function openCamera(facing) {
+    return navigator.mediaDevices.getUserMedia({
+        video: { facingMode: { ideal: facing }, width: { ideal: 640 }, height: { ideal: 480 } },
+        audio: false,
+    });
+}
+export function startLiveVideoCapture(onFrame, options) {
+    const initialFacing = options?.facingMode ?? 'user';
+    return openCamera(initialFacing).then((stream) => {
+        const video = document.createElement('video');
+        video.srcObject = stream;
+        video.muted = true;
+        video.playsInline = true;
+        video.setAttribute('playsinline', '');
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+        if (!context) {
+            for (const track of stream.getTracks())
+                track.stop();
+            throw new TheoremError('unsupported', 'no 2d canvas for live video'); // lexicon-exempt: internal diagnostic
+        }
+        let timer = null;
+        let stopped = false;
+        let state = { stream, facing: initialFacing };
+        const capture = () => {
+            if (stopped || video.videoWidth === 0)
+                return;
+            canvas.width = video.videoWidth;
+            canvas.height = video.videoHeight;
+            context.drawImage(video, 0, 0);
+            const dataUrl = canvas.toDataURL('image/jpeg', JPEG_QUALITY);
+            const base64 = dataUrl.split(',')[1];
+            if (base64)
+                onFrame(base64);
+        };
+        const startTimer = () => {
+            if (timer || stopped)
+                return;
+            timer = setInterval(capture, FRAME_INTERVAL_MS);
+        };
+        void video.play().then(startTimer);
+        return {
+            video,
+            facingMode: () => state.facing,
+            flip: async () => {
+                if (stopped)
+                    return state.facing;
+                const nextFacing = state.facing === 'user' ? 'environment' : 'user';
+                const nextStream = await openCamera(nextFacing);
+                for (const track of state.stream.getTracks())
+                    track.stop();
+                state = { stream: nextStream, facing: nextFacing };
+                video.srcObject = nextStream;
+                await video.play();
+                return nextFacing;
+            },
+            stop: () => {
+                stopped = true;
+                if (timer)
+                    clearInterval(timer);
+                timer = null;
+                video.srcObject = null;
+                for (const track of state.stream.getTracks())
+                    track.stop();
+            },
+        };
+    });
+}

package/client/live/run-live-tool-call.d.ts

@@ -0,0 +1,17 @@
+import type { ExecuteToolOnRelay } from '../live-messages.ts';
+import type { LiveGateAnswer, LiveToolGatePrompt } from './live-tool.ts';
+/**
+ * Live provider tool-call handler: run the model's call on the relay; at a
+ * gate, ask the user and send their decision. The session answers the model
+ * however the call ends; its tool events tell the user. A call the model
+ * cancels while its gate is open is gone: nothing is sent.
+ */
+export declare function runLiveToolCall(args: {
+    executeToolOnRelay: ExecuteToolOnRelay;
+    name: string;
+    toolArgs: Record<string, unknown>;
+    callId: string;
+    sessionPermissions: string[];
+    setSessionPermissions: (next: string[]) => void;
+    waitForGateDecision: (prompt: LiveToolGatePrompt) => Promise<LiveGateAnswer>;
+}): Promise<void>;

package/client/live/run-live-tool-call.js

@@ -0,0 +1,32 @@
+import { continueGatedToolInvocation } from "../tool-resume.js";
+/**
+ * Live provider tool-call handler: run the model's call on the relay; at a
+ * gate, ask the user and send their decision. The session answers the model
+ * however the call ends; its tool events tell the user. A call the model
+ * cancels while its gate is open is gone: nothing is sent.
+ */
+export async function runLiveToolCall(args) {
+    const { executeToolOnRelay, name, toolArgs, callId } = args;
+    let sessionPermissions = args.sessionPermissions;
+    let step = await executeToolOnRelay({ callId });
+    while (step.status === 'gated') {
+        const { gate } = step;
+        const resolution = await args.waitForGateDecision({ callId, toolName: name, input: toolArgs, gate });
+        if (resolution === 'withdrawn')
+            return;
+        const reply = continueGatedToolInvocation({ toolName: name, gate, sessionPermissions, resolution });
+        if (reply.decision === 'deny') {
+            // The session settles the refusal; its tool event tells the user.
+            await executeToolOnRelay({ callId, decision: 'deny' });
+            return;
+        }
+        sessionPermissions = reply.sessionPermissions;
+        args.setSessionPermissions(reply.sessionPermissions);
+        // Signed in: a typed key goes once, with the approval; after an OAuth callback there is none.
+        step = await executeToolOnRelay({
+            callId,
+            decision: 'approve',
+            ...(reply.secret !== undefined ? { secret: reply.secret } : {}),
+        });
+    }
+}

package/client/live-client.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Pure client-side SDK for THEOREM Gemini 3.1 Flash Live sessions over WebSocket relay.
+ *
+ * Handles:
+ * - Bidirectional WebSocket connection to `/api/live/relay`.
+ * - 16-bit 16kHz PCM microphone audio recording & streaming.
+ * - Gapless 24kHz PCM / WAV model voice playback scheduling.
+ * - Barge-in interruption cancellation (instant audio queue flush).
+ * - Quiet-mic gate while model audio plays (reduces false barge-in from speaker bleed).
+ * - UI tool execution and response routing.
+ *
+ * @module
+ */
+import { type SessionEventOf, type TraceRecord } from '@theoremjs/agents';
+import type { LiveConnectPhase, LiveSessionStatus } from './live/live-state.ts';
+import { type ExecuteToolOnRelay, type LiveToolStep } from './live-messages.ts';
+import { type ClientTurnEvent } from './transport.ts';
+export type { LiveConnection, LiveSocket } from './live-messages.ts';
+import type { LiveSocket } from './live-messages.ts';
+export interface LiveClientOptions {
+    profile?: string;
+    /** JSON sent before anything else, as the socket opens. */
+    openMessage?: Record<string, unknown>;
+    relayUrl?: string;
+    /** In-process connections reuse the same microphone, playback and tool client. */
+    createSocket?: () => LiveSocket;
+    /** When false, skip microphone capture; session still receives model audio. */
+    voiceIngress?: boolean;
+    onStatusChange?: (status: LiveSessionStatus) => void;
+    onConnectPhase?: (phase: LiveConnectPhase | null) => void;
+    onTranscript?: (text: string, isUser: boolean, meta?: {
+        interim?: boolean;
+    }) => void;
+    /**
+     * Every event the session sends, `unsupported` for a kind this client does
+     * not know, and `malformed` for one that failed its check (left out; the call goes on).
+     */
+    onTurnEvent?: (event: ClientTurnEvent) => void;
+    /** A trace record the session wrote, when the relay delivers them. */
+    onTrace?: (record: TraceRecord) => void;
+    /** A failure, typed by kind; word it with `clientFailure` and the interface's `lexicon`. */
+    onError?: (error: Error) => void;
+    /** Provider signalled the upstream session is draining (e.g. goAway). */
+    onSessionClosing?: (timeLeftMs?: number) => void;
+    /**
+     * The provider ended the session after warning it would: not a failure.
+     * `session.message` is the user's line; `session.ended` the close, for the builder.
+     */
+    onSessionEnded?: (session: SessionEventOf<'ended'>) => void;
+    /**
+     * The model called a tool. The host runs it with `executeToolOnRelay` and
+     * answers its gates; the session answers the model. A throw reaches `onError`.
+     */
+    onToolCall: (name: string, args: Record<string, unknown>, meta: {
+        callId: string;
+    }) => Promise<void>;
+    /** The relay opened the call: the id it gave the call, and the profile it runs. */
+    onSessionReady?: (info: {
+        sessionId?: string;
+        profile?: string;
+    }) => void;
+    onVolumeLevel?: (level: number, isUser: boolean) => void;
+}
+export declare class LiveSessionClient {
+    private ws;
+    private audioContext;
+    private micStream;
+    private micSource;
+    private micWorklet;
+    private micWorkletModuleLoaded;
+    private playbackNodes;
+    private playbackBus;
+    private playbackAnalyser;
+    private playbackMeterFrame;
+    private playbackMeterBuffer;
+    private nextPlaybackTime;
+    private status;
+    /** Server reported background work (reasoning / async tools) still in flight. */
+    private serverWorking;
+    private micActivating;
+    private connectTimeout;
+    private isMuted;
+    private options;
+    /** Serialize control-plane handling (tools / status) without waiting on audio decode. */
+    private inboundChain;
+    /** Ordered model-audio playback queue (separate so tools are not stuck behind decode). */
+    private audioChain;
+    /**
+     * Tool calls, one at a time in the order the model made them. Apart from
+     * `inboundChain`: a call waits on the relay's reply, which arrives inbound.
+     */
+    private toolChain;
+    /** Bumped on barge-in / cancel so stale audioChain work is skipped. */
+    private audioEpoch;
+    private pendingExecuteResults;
+    constructor(options: LiveClientOptions);
+    private setStatus;
+    private setConnectPhase;
+    private clearConnectTimeout;
+    private detachWebSocket;
+    private teardownConnection;
+    /** End the session on `error`: a failed connect or a lost socket. */
+    private failSession;
+    private createSocket;
+    connect(): Promise<void>;
+    private ensureAudioContext;
+    private activateMicrophone;
+    private sendMicFrame;
+    private reportMicVolume;
+    private forwardMicBuffer;
+    private setupMicrophonePipeline;
+    private ensurePlaybackBus;
+    private stopPlaybackMeter;
+    private startPlaybackMeter;
+    private processServerEnvelope;
+    private enqueueServerMessage;
+    private handleReadyEnvelope;
+    private handleExecuteToolResultEnvelope;
+    private tryHandleControlEnvelope;
+    private collectInboundTurn;
+    private processTurnEvent;
+    private handleEvidenceTurnEvent;
+    private handleSessionTurnEvent;
+    /** Hand the session's closing and end to the host; `true` when it was one of them. */
+    private notifySessionLifecycle;
+    /** Status to settle into once model speech stops. */
+    private restingStatus;
+    private collectMediaTurnEvent;
+    private handleDoneTurnEvent;
+    private scheduleMediaChunks;
+    /** The relay runs `LiveSession.executeTool`; see `ExecuteToolOnRelay`. */
+    executeToolOnRelay(args: Parameters<ExecuteToolOnRelay>[0]): Promise<LiveToolStep>;
+    private enqueueAudioChunk;
+    cancelPlayback(): void;
+    toggleMute(): boolean;
+    sendText(text: string): void;
+    sendContext(text: string): void;
+    sendVideo(data: string, mimeType?: string): void;
+    disconnect(): void;
+    private cleanupAudio;
+}