@nextpa/chat-core 0.1.0

package/dist/services/realtime/google/google-provider.js

@@ -0,0 +1,465 @@
+import { GoogleGenAI, MediaModality, Modality, VoiceActivityType } from '@google/genai';
+import { mapToolsForGoogle } from './google-tool-mapper';
+import { GoogleAudioHandler } from './google-audio';
+import { logger } from '../../../utils/logger';
+const AUDIO_MIME_TYPE = 'audio/pcm;rate=16000';
+const DEFAULT_VOICE = 'Kore';
+const MAX_TOOL_CALL_HISTORY = 5;
+const PLAYBACK_CHECK_INTERVAL_MS = 100;
+const PLAYBACK_SETTLED_CHECKS = 3;
+const DEFAULT_MAX_WAIT_MS = 20000;
+export class GoogleRealtimeProvider {
+    session = null;
+    audioHandler;
+    eventHandlers = new Map();
+    _status = 'disconnected';
+    pendingFunctionCalls = new Map();
+    awaitingToolResponse = false;
+    isSetupComplete = false;
+    modelResponding = false;
+    userSpeaking = false;
+    pendingCommands = [];
+    outputTranscriptBuffer = '';
+    inputTranscriptBuffer = '';
+    lastCompletedToolCalls = [];
+    constructor() {
+        this.audioHandler = new GoogleAudioHandler();
+    }
+    get status() {
+        return this._status;
+    }
+    async connect(config) {
+        this._status = 'connecting';
+        this.emit('connectionStateChanged', 'connecting');
+        // Ephemeral tokens require v1alpha
+        const ai = new GoogleGenAI({
+            apiKey: config.apiKey,
+            httpOptions: { apiVersion: 'v1alpha' },
+        });
+        const toolDeclarations = mapToolsForGoogle(config.tools);
+        logger.debug('[Google] Connecting to Live API, model:', config.model, 'tools:', toolDeclarations.length, 'voice:', config.voice);
+        // languageCodes pin the ASR + TTS to a specific BCP-47 locale so
+        // Gemini doesn't drift into Spanish/Hindi on quiet inputs (observed
+        // live during M3-i easybell trunk testing). Empty list when the
+        // tenant has no configured locale — Gemini auto-detects then.
+        const transcriptionLanguageCodes = config.transcription?.language
+            ? [config.transcription.language]
+            : undefined;
+        const liveConfig = {
+            responseModalities: [Modality.AUDIO],
+            speechConfig: {
+                voiceConfig: {
+                    prebuiltVoiceConfig: {
+                        voiceName: config.voice || DEFAULT_VOICE,
+                    },
+                },
+            },
+            inputAudioTranscription: transcriptionLanguageCodes
+                ? { languageCodes: transcriptionLanguageCodes }
+                : {},
+            outputAudioTranscription: transcriptionLanguageCodes
+                ? { languageCodes: transcriptionLanguageCodes }
+                : {},
+        };
+        if (config.instructions) {
+            liveConfig.systemInstruction = config.instructions;
+        }
+        if (toolDeclarations.length > 0) {
+            liveConfig.tools = [{ functionDeclarations: toolDeclarations }];
+        }
+        this.session = await ai.live.connect({
+            model: config.model,
+            config: liveConfig,
+            callbacks: {
+                onopen: () => {
+                    logger.debug('[Google] WebSocket opened');
+                    this._status = 'connected';
+                    this.emit('connectionStateChanged', 'connected');
+                },
+                onmessage: (message) => {
+                    this.handleServerMessage(message);
+                },
+                onerror: (error) => {
+                    logger.error('[Google] WebSocket error:', error.message || error);
+                    this.emit('error', { message: error.message || 'Google Live API error' });
+                },
+                onclose: (event) => {
+                    logger.warn('[Google] WebSocket closed, code:', event.code, 'reason:', event.reason, '— modelResponding:', this.modelResponding, 'pendingToolCalls:', this.pendingFunctionCalls.size, 'lastToolCalls:', this.lastCompletedToolCalls.join(' | ') || 'none');
+                    this._status = 'disconnected';
+                    this.resetSessionState();
+                    this.audioHandler.stop();
+                    this.emit('connectionStateChanged', 'disconnected');
+                },
+            },
+        });
+        this.audioHandler.onAudioData = (base64Pcm) => {
+            if (this.session && this.isSetupComplete && this._status === 'connected'
+                && this.pendingFunctionCalls.size === 0) {
+                try {
+                    this.session.sendRealtimeInput({
+                        audio: { data: base64Pcm, mimeType: AUDIO_MIME_TYPE },
+                    });
+                }
+                catch (error) {
+                    logger.debug('[Google] sendRealtimeInput failed:', error);
+                }
+            }
+        };
+        logger.debug('[Google] Session established, starting audio capture');
+        await this.audioHandler.startCapture();
+    }
+    close() {
+        if (this.session) {
+            this.session.close();
+            this.session = null;
+        }
+        this.audioHandler.stop();
+        this._status = 'disconnected';
+        this.resetSessionState();
+    }
+    resumeAudio() {
+        this.audioHandler.resume();
+    }
+    mute(muted) {
+        this.audioHandler.setMuted(muted);
+    }
+    interrupt() {
+        // Gemini Live has no client-side response-cancel; dropping the queued
+        // playback stops the talking immediately, which is what the user wants.
+        this.audioHandler.clearPlaybackQueue();
+        this.emit('interrupted');
+    }
+    requestResponse() {
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'requestResponse' });
+            return;
+        }
+        this.executeRequestResponse();
+    }
+    sendToolResult(callId, name, output) {
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'sendToolResult', payload: { callId, name, output } });
+            return;
+        }
+        this.executeSendToolResult(callId, name, output);
+    }
+    sendText(text) {
+        if (!this.session)
+            return;
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'sendText', payload: text });
+            return;
+        }
+        this.session.sendRealtimeInput({ text });
+    }
+    waitForAudioPlaybackEnd(timeoutMs = DEFAULT_MAX_WAIT_MS) {
+        return new Promise((resolve) => {
+            if (!this.audioHandler.isPlaybackActive) {
+                resolve('no active playback');
+                return;
+            }
+            let settledCount = 0;
+            const interval = setInterval(() => {
+                if (this.audioHandler.isPlaybackActive) {
+                    settledCount = 0;
+                }
+                else {
+                    settledCount++;
+                    if (settledCount >= PLAYBACK_SETTLED_CHECKS) {
+                        clearInterval(interval);
+                        resolve('playback complete');
+                    }
+                }
+            }, PLAYBACK_CHECK_INTERVAL_MS);
+            setTimeout(() => {
+                clearInterval(interval);
+                resolve('max wait reached');
+            }, timeoutMs);
+        });
+    }
+    async refreshAudioDevice() {
+        logger.debug('[Google] Refreshing audio device (restarting capture)');
+        await this.audioHandler.restartCapture();
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+        return () => this.off(event, handler);
+    }
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    emit(event, ...args) {
+        const handlers = this.eventHandlers.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            handler(...args);
+        }
+    }
+    resetSessionState() {
+        this.session = null;
+        this.isSetupComplete = false;
+        this.awaitingToolResponse = false;
+        this.modelResponding = false;
+        this.userSpeaking = false;
+        this.pendingFunctionCalls.clear();
+        this.pendingCommands = [];
+        this.outputTranscriptBuffer = '';
+        this.inputTranscriptBuffer = '';
+        this.lastCompletedToolCalls = [];
+    }
+    executeRequestResponse() {
+        if (!this.session)
+            return;
+        if (this.awaitingToolResponse) {
+            logger.debug('[Google] Skipping requestResponse — Google auto-continues after tool response');
+            this.awaitingToolResponse = false;
+            return;
+        }
+        if (this.pendingFunctionCalls.size > 0 || this.modelResponding) {
+            logger.debug('[Google] Skipping requestResponse — model busy');
+            return;
+        }
+        this.session.sendRealtimeInput({ text: '.' });
+    }
+    executeSendToolResult(callId, name, output) {
+        if (!this.session)
+            return;
+        this.awaitingToolResponse = true;
+        const funcName = this.pendingFunctionCalls.get(callId)?.name ?? name;
+        const rawOutput = output;
+        let parsedResult;
+        try {
+            const parsed = JSON.parse(rawOutput);
+            parsedResult =
+                typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+                    ? parsed
+                    : { output: parsed };
+        }
+        catch {
+            parsedResult = { output: rawOutput };
+        }
+        const functionResponse = {
+            id: callId,
+            name: funcName,
+            response: parsedResult,
+        };
+        try {
+            this.session.sendToolResponse({ functionResponses: [functionResponse] });
+            logger.debug('[Google] Tool response sent for', funcName, 'size:', rawOutput.length);
+            this.lastCompletedToolCalls.push(`${funcName}(${rawOutput.slice(0, 100)})`);
+            if (this.lastCompletedToolCalls.length > MAX_TOOL_CALL_HISTORY) {
+                this.lastCompletedToolCalls.shift();
+            }
+        }
+        catch (error) {
+            logger.error('[Google] Failed to send tool response for', funcName, error);
+            this.emit('error', { message: `Tool response failed for ${funcName}: ${error}` });
+        }
+        finally {
+            this.pendingFunctionCalls.delete(callId);
+            if (this.pendingFunctionCalls.size === 0) {
+                this.modelResponding = false;
+                this.audioHandler.resumeCapture();
+            }
+        }
+    }
+    finalizeInputTranscript() {
+        if (this.inputTranscriptBuffer) {
+            this.emit('userTranscriptCompleted', this.inputTranscriptBuffer);
+            this.inputTranscriptBuffer = '';
+        }
+    }
+    handleServerMessage(message) {
+        const msgRecord = message;
+        const keys = Object.keys(msgRecord).filter((k) => msgRecord[k] != null);
+        logger.debug('[Google] message keys:', keys.join(', '));
+        if (message.setupComplete !== undefined) {
+            logger.debug('[Google] Setup complete');
+            this.isSetupComplete = true;
+            this.emit('sessionReady');
+            this.flushPendingCommands();
+            return;
+        }
+        if (message.voiceActivity) {
+            this.handleVoiceActivity(message.voiceActivity);
+        }
+        if (message.usageMetadata) {
+            this.extractAndEmitUsage(message.usageMetadata);
+        }
+        if (message.serverContent) {
+            this.handleServerContent(message.serverContent);
+        }
+        if (message.toolCall) {
+            this.ensureSpeechStopped();
+            this.handleToolCall(message.toolCall);
+        }
+        if (message.toolCallCancellation) {
+            logger.debug('[Google] Tool call cancelled, clearing', this.pendingFunctionCalls.size, 'pending calls');
+            this.pendingFunctionCalls.clear();
+            this.modelResponding = false;
+            this.audioHandler.resumeCapture();
+            this.audioHandler.clearPlaybackQueue();
+        }
+        const serverMessage = message;
+        if (serverMessage.goAway) {
+            const goAway = serverMessage.goAway;
+            const timeLeft = goAway.timeLeft;
+            logger.warn('[Google] Server disconnecting soon, timeLeft:', timeLeft);
+            this.emit('serverDisconnecting', timeLeft);
+        }
+    }
+    extractAndEmitUsage(metadata) {
+        logger.debug('[Google Live] Raw usage metadata:', JSON.stringify(metadata));
+        const inputTokens = metadata.promptTokenCount ?? 0;
+        const outputTokens = metadata.responseTokenCount ?? 0;
+        const totalTokens = metadata.totalTokenCount ?? (inputTokens + outputTokens);
+        const findModality = (details, modality) => details?.find((d) => d.modality === modality)?.tokenCount ?? undefined;
+        const providerUsage = {
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            cachedTokens: metadata.cachedContentTokenCount ?? undefined,
+            audioInputTokens: findModality(metadata.promptTokensDetails, MediaModality.AUDIO),
+            audioOutputTokens: findModality(metadata.responseTokensDetails, MediaModality.AUDIO),
+            textInputTokens: findModality(metadata.promptTokensDetails, MediaModality.TEXT),
+            textOutputTokens: findModality(metadata.responseTokensDetails, MediaModality.TEXT),
+        };
+        this.emit('usageUpdated', providerUsage);
+    }
+    flushPendingCommands() {
+        const commands = this.pendingCommands;
+        this.pendingCommands = [];
+        for (const cmd of commands) {
+            switch (cmd.type) {
+                case 'requestResponse':
+                    this.executeRequestResponse();
+                    break;
+                case 'sendToolResult': {
+                    const p = cmd.payload;
+                    this.executeSendToolResult(p.callId, p.name, p.output);
+                    break;
+                }
+                case 'sendText':
+                    this.sendText(cmd.payload);
+                    break;
+            }
+        }
+    }
+    handleVoiceActivity(activity) {
+        if (activity.voiceActivityType === VoiceActivityType.ACTIVITY_START && !this.userSpeaking) {
+            logger.debug('[Google] Voice activity: ACTIVITY_START');
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        }
+        else if (activity.voiceActivityType === VoiceActivityType.ACTIVITY_END && this.userSpeaking) {
+            logger.debug('[Google] Voice activity: ACTIVITY_END');
+            this.ensureSpeechStopped();
+        }
+    }
+    handleServerContent(content) {
+        const hasContent = content.inputTranscription || content.outputTranscription
+            || content.modelTurn || content.turnComplete;
+        if (!hasContent && !this.modelResponding && !this.userSpeaking) {
+            logger.debug('[Google] Speech activity detected (empty serverContent fallback)');
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        }
+        if (content.inputTranscription?.text) {
+            logger.debug('[Google] inputTranscription text:', content.inputTranscription.text.slice(0, 80));
+            if (!this.userSpeaking) {
+                this.userSpeaking = true;
+                this.emit('userSpeechStarted');
+            }
+            this.inputTranscriptBuffer += content.inputTranscription.text;
+            this.emit('userTranscriptDelta', content.inputTranscription.text);
+        }
+        if (content.inputTranscription?.finished) {
+            logger.debug('[Google] inputTranscription finished');
+            this.finalizeInputTranscript();
+            this.emit('userSpeechStopped');
+            this.userSpeaking = false;
+        }
+        const isFirstModelResponse = content.modelTurn && !this.modelResponding;
+        if (content.modelTurn) {
+            this.handleModelTurn(content);
+        }
+        if (content.outputTranscription?.text) {
+            if (isFirstModelResponse) {
+                this.deferAssistantTranscript(content.outputTranscription.text);
+            }
+            else {
+                this.outputTranscriptBuffer += content.outputTranscription.text;
+                this.emit('assistantTranscriptDelta', content.outputTranscription.text);
+            }
+        }
+        if (content.turnComplete) {
+            this.handleTurnComplete();
+        }
+        if (content.interrupted) {
+            this.handleInterrupted();
+        }
+    }
+    static THINKING_RENDER_DELAY_MS = 150;
+    deferAssistantTranscript(text) {
+        setTimeout(() => {
+            this.outputTranscriptBuffer += text;
+            this.emit('assistantTranscriptDelta', text);
+        }, GoogleRealtimeProvider.THINKING_RENDER_DELAY_MS);
+    }
+    ensureSpeechStopped() {
+        if (this.inputTranscriptBuffer) {
+            this.finalizeInputTranscript();
+        }
+        this.userSpeaking = false;
+        this.emit('userSpeechStopped');
+    }
+    handleModelTurn(content) {
+        if (!this.modelResponding) {
+            logger.debug('[Google] Model turn started');
+        }
+        this.modelResponding = true;
+        this.ensureSpeechStopped();
+        if (content.modelTurn?.parts) {
+            for (const part of content.modelTurn.parts) {
+                if (part.inlineData?.mimeType?.startsWith('audio/') && part.inlineData.data) {
+                    this.audioHandler.playAudio(part.inlineData.data);
+                }
+            }
+        }
+    }
+    handleTurnComplete() {
+        logger.debug('[Google] Turn complete');
+        this.modelResponding = false;
+        if (this.outputTranscriptBuffer) {
+            this.emit('assistantTranscriptDone', this.outputTranscriptBuffer);
+        }
+        this.outputTranscriptBuffer = '';
+        this.emit('audioDone');
+    }
+    handleInterrupted() {
+        logger.debug('[Google] Model interrupted');
+        this.modelResponding = false;
+        this.finalizeInputTranscript();
+        this.outputTranscriptBuffer = '';
+        this.audioHandler.clearPlaybackQueue();
+        this.emit('interrupted');
+    }
+    handleToolCall(toolCall) {
+        if (!toolCall.functionCalls)
+            return;
+        this.modelResponding = true;
+        this.audioHandler.pauseCapture();
+        for (const fc of toolCall.functionCalls) {
+            const callId = fc.id || `call_${Date.now()}`;
+            const name = fc.name ?? '';
+            const args = JSON.stringify(fc.args || {});
+            logger.debug('[Google] Tool call received:', name, 'args:', args);
+            this.pendingFunctionCalls.set(callId, { name, args });
+            this.emit('functionCall', { callId, name, arguments: args });
+        }
+    }
+}

package/dist/services/realtime/google/google-tool-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionDeclaration } from '@google/genai';
+import type { ToolDefinition } from '../../../types';
+export declare function mapToolsForGoogle(tools: ToolDefinition[]): FunctionDeclaration[];

package/dist/services/realtime/google/google-tool-mapper.js

@@ -0,0 +1,70 @@
+export function mapToolsForGoogle(tools) {
+    return tools.map((tool) => {
+        const declaration = {
+            name: tool.name,
+            description: tool.description,
+        };
+        const properties = tool.parameters.properties;
+        const hasProperties = Object.keys(properties).length > 0;
+        if (hasProperties) {
+            declaration.parameters = {
+                type: 'OBJECT',
+                properties: Object.fromEntries(Object.entries(properties).map(([key, prop]) => [key, toGoogleSchema(prop)])),
+                required: tool.parameters.required && tool.parameters.required.length > 0
+                    ? tool.parameters.required
+                    : undefined,
+            };
+        }
+        return declaration;
+    });
+}
+function toGoogleSchema(prop) {
+    const schema = {
+        type: mapType(prop.type),
+        description: prop.description || undefined,
+    };
+    if (prop.format) {
+        schema.format = prop.format;
+    }
+    if (prop.enum) {
+        schema.enum = prop.enum.map(String);
+    }
+    if (prop.items) {
+        schema.items = toGoogleSchema(prop.items);
+    }
+    if (prop.properties) {
+        schema.properties = Object.fromEntries(Object.entries(prop.properties).map(([key, nested]) => [key, toGoogleSchema(nested)]));
+    }
+    if (prop.required && prop.required.length > 0) {
+        schema.required = prop.required;
+    }
+    return schema;
+}
+function mapType(type) {
+    if (typeof type === 'string') {
+        return jsonSchemaTypeToGoogle(type);
+    }
+    if (Array.isArray(type)) {
+        const nonNull = type.filter((t) => t !== 'null');
+        return nonNull.length > 0 ? jsonSchemaTypeToGoogle(nonNull[0]) : 'STRING';
+    }
+    return 'STRING';
+}
+function jsonSchemaTypeToGoogle(type) {
+    switch (type.toLowerCase()) {
+        case 'string':
+            return 'STRING';
+        case 'number':
+            return 'NUMBER';
+        case 'integer':
+            return 'INTEGER';
+        case 'boolean':
+            return 'BOOLEAN';
+        case 'array':
+            return 'ARRAY';
+        case 'object':
+            return 'OBJECT';
+        default:
+            return 'STRING';
+    }
+}

package/dist/services/realtime/google/index.d.ts

@@ -0,0 +1 @@
+export { GoogleRealtimeProvider } from './google-provider';

package/dist/services/realtime/google/index.js

@@ -0,0 +1 @@
+export { GoogleRealtimeProvider } from './google-provider';

package/dist/services/realtime/openai/index.d.ts

@@ -0,0 +1 @@
+export { OpenAiRealtimeProvider } from './openai-provider';

package/dist/services/realtime/openai/index.js

@@ -0,0 +1 @@
+export { OpenAiRealtimeProvider } from './openai-provider';

package/dist/services/realtime/openai/openai-audio-monitor.d.ts

@@ -0,0 +1 @@
+export declare function waitForAudioPlaybackEnd(peerConnection: RTCPeerConnection, maxWaitMs?: number): Promise<string>;

package/dist/services/realtime/openai/openai-audio-monitor.js

@@ -0,0 +1,55 @@
+const CHECK_INTERVAL_MS = 150;
+const REQUIRED_SILENCE_CHECKS = 5;
+const ENERGY_DELTA_THRESHOLD = 0.001;
+const SILENCE_DELAY_MS = 300;
+const DEFAULT_MAX_WAIT_MS = 20000;
+export function waitForAudioPlaybackEnd(peerConnection, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
+    return new Promise((resolve, reject) => {
+        const audioReceiver = peerConnection.getReceivers()
+            .find(r => r.track?.kind === 'audio');
+        if (!audioReceiver) {
+            reject(new Error('No audio receiver'));
+            return;
+        }
+        let lastEnergy = -1;
+        let silenceCount = 0;
+        const interval = setInterval(async () => {
+            try {
+                const currentEnergy = extractAudioEnergy(await audioReceiver.getStats());
+                if (currentEnergy < 0) {
+                    clearInterval(interval);
+                    reject(new Error('totalAudioEnergy not available'));
+                    return;
+                }
+                if (lastEnergy >= 0) {
+                    const isSilent = currentEnergy - lastEnergy < ENERGY_DELTA_THRESHOLD;
+                    silenceCount = isSilent ? silenceCount + 1 : 0;
+                    if (silenceCount >= REQUIRED_SILENCE_CHECKS) {
+                        clearInterval(interval);
+                        setTimeout(() => resolve('silence detected'), SILENCE_DELAY_MS);
+                        return;
+                    }
+                }
+                lastEnergy = currentEnergy;
+            }
+            catch {
+                clearInterval(interval);
+                reject(new Error('getStats failed'));
+            }
+        }, CHECK_INTERVAL_MS);
+        setTimeout(() => {
+            clearInterval(interval);
+            resolve('max wait reached');
+        }, maxWaitMs);
+    });
+}
+function extractAudioEnergy(stats) {
+    let energy = -1;
+    stats.forEach((report) => {
+        const rtpReport = report;
+        if (rtpReport.type === 'inbound-rtp' && rtpReport.totalAudioEnergy !== undefined) {
+            energy = rtpReport.totalAudioEnergy;
+        }
+    });
+    return energy;
+}

package/dist/services/realtime/openai/openai-provider.d.ts

@@ -0,0 +1,50 @@
+import type { RealtimeProviderClient, RealtimeProviderConnectConfig, ProviderEventMap } from '../types';
+export declare class OpenAiRealtimeProvider implements RealtimeProviderClient {
+    private readonly client;
+    private readonly eventHandlers;
+    private readonly oobResponseIds;
+    private readonly oobResponseBuffers;
+    private transcriptionConfig;
+    private outputAudioPlaying;
+    private sawOutputAudioBufferEvents;
+    private readonly playbackEndWaiters;
+    private analyserContext;
+    private analyserNode;
+    private analyserRafId;
+    private readonly audioElement;
+    constructor();
+    get status(): 'disconnected' | 'connecting' | 'connected';
+    connect(config: RealtimeProviderConnectConfig): Promise<void>;
+    close(): void;
+    resumeAudio(): void;
+    mute(muted: boolean): void;
+    interrupt(): void;
+    requestResponse(): void;
+    sendToolResult(callId: string, name: string, output: string): void;
+    sendText(text: string): void;
+    waitForAudioPlaybackEnd(timeoutMs?: number): Promise<string>;
+    private resolvePlaybackEndWaiters;
+    refreshAudioDevice(): Promise<void>;
+    on<K extends keyof ProviderEventMap>(event: K, handler: ProviderEventMap[K]): () => void;
+    off<K extends keyof ProviderEventMap>(event: K, handler: ProviderEventMap[K]): void;
+    private emit;
+    private getPeerConnection;
+    private applyMicNoiseConstraints;
+    private startAudioLevelAnalysis;
+    private stopAudioLevelAnalysis;
+    private setupInternalEventHandlers;
+    private handleServerEvent;
+    private handleAudioCommitted;
+    private handleResponseCreated;
+    private handleTextDelta;
+    private handleResponseDone;
+    private extractAndEmitUsage;
+    private processResponseOutput;
+    private finalizeOobTranscription;
+    private buildOobPrompt;
+    private handleNativeTranscriptionCompleted;
+    private emitAssistantDelta;
+    private handleAudioTranscriptDone;
+    private handleFunctionCallDone;
+    private handleError;
+}