@mastra/voice-google-gemini-live 0.0.0-add-libsql-changeset-20250910154739

package/dist/index.js

@@ -0,0 +1,2786 @@
+import { randomUUID } from 'crypto';
+import { MastraVoice } from '@mastra/core/voice';
+import { WebSocket } from 'ws';
+import { PassThrough } from 'stream';
+import { EventEmitter } from 'events';
+import { GoogleAuth } from 'google-auth-library';
+
+// src/index.ts
+var DEFAULT_AUDIO_CONFIG = {
+  inputSampleRate: 16e3,
+  outputSampleRate: 24e3,
+  encoding: "pcm16",
+  channels: 1
+};
+var AudioStreamManager = class {
+  speakerStreams = /* @__PURE__ */ new Map();
+  currentResponseId;
+  MAX_CONCURRENT_STREAMS = 10;
+  STREAM_TIMEOUT_MS = 3e4;
+  // 30 seconds
+  debug;
+  audioConfig;
+  maxChunkSize = 32768;
+  // 32KB max chunk size per Gemini limits
+  minSendInterval = 0;
+  // No throttling - let the stream control the pace
+  lastSendTime = 0;
+  pendingChunks = [];
+  pendingTimer;
+  sendToGemini;
+  // Audio buffer management constants
+  MAX_BUFFER_SIZE = 50 * 1024 * 1024;
+  // 50MB maximum buffer size
+  MAX_AUDIO_DURATION = 300;
+  // 5 minutes maximum audio duration
+  constructor(audioConfig, debug = false) {
+    this.audioConfig = audioConfig;
+    this.debug = debug;
+  }
+  /**
+   * Provide a sender callback that will be used to deliver messages to Gemini
+   */
+  setSender(sender) {
+    this.sendToGemini = sender;
+  }
+  /**
+   * Get the default audio configuration
+   */
+  static getDefaultAudioConfig() {
+    return { ...DEFAULT_AUDIO_CONFIG };
+  }
+  /**
+   * Create a merged audio configuration with defaults
+   */
+  static createAudioConfig(customConfig) {
+    return {
+      ...DEFAULT_AUDIO_CONFIG,
+      ...customConfig
+    };
+  }
+  /**
+   * Get the current response ID for the next audio chunk
+   */
+  getCurrentResponseId() {
+    return this.currentResponseId;
+  }
+  /**
+   * Set the current response ID for the next audio chunk
+   */
+  setCurrentResponseId(responseId) {
+    this.currentResponseId = responseId;
+  }
+  /**
+   * Get the current speaker stream
+   */
+  getCurrentSpeakerStream() {
+    const currentResponseId = this.getCurrentResponseId();
+    if (!currentResponseId) {
+      return null;
+    }
+    const currentStream = this.speakerStreams.get(currentResponseId);
+    return currentStream ? currentStream : null;
+  }
+  /**
+   * Add a new speaker stream for a response
+   */
+  addSpeakerStream(responseId, stream) {
+    const streamWithMetadata = Object.assign(stream, {
+      id: responseId,
+      created: Date.now()
+    });
+    this.speakerStreams.set(responseId, streamWithMetadata);
+    this.log(`Added speaker stream for response: ${responseId}`);
+    this.enforceStreamLimits();
+  }
+  /**
+   * Remove a specific speaker stream
+   */
+  removeSpeakerStream(responseId) {
+    const stream = this.speakerStreams.get(responseId);
+    if (stream && !stream.destroyed) {
+      stream.end();
+      setTimeout(() => {
+        if (!stream.destroyed) {
+          stream.destroy();
+          this.log(`Force destroyed stream for response: ${responseId}`);
+        }
+      }, 1e3);
+    }
+    this.speakerStreams.delete(responseId);
+    this.log(`Removed speaker stream for response: ${responseId}`);
+  }
+  /**
+   * Clean up all speaker streams
+   */
+  cleanupSpeakerStreams() {
+    try {
+      if (this.speakerStreams.size === 0) {
+        return;
+      }
+      this.log(`Cleaning up ${this.speakerStreams.size} speaker streams`);
+      for (const [responseId, stream] of this.speakerStreams.entries()) {
+        try {
+          if (!stream.destroyed) {
+            stream.end();
+            setTimeout(() => {
+              if (!stream.destroyed) {
+                stream.destroy();
+                this.log(`Force destroyed stream for response: ${responseId}`);
+              }
+            }, 1e3);
+          }
+          this.speakerStreams.delete(responseId);
+          this.log(`Cleaned up speaker stream for response: ${responseId}`);
+        } catch (streamError) {
+          this.log(`Error cleaning up stream ${responseId}:`, streamError);
+          this.speakerStreams.delete(responseId);
+        }
+      }
+      this.currentResponseId = void 0;
+      this.log("All speaker streams cleaned up");
+    } catch (error) {
+      this.log("Error during speaker stream cleanup:", error);
+      this.speakerStreams.clear();
+      this.currentResponseId = void 0;
+    }
+  }
+  /**
+   * Clean up old/stale streams to prevent memory leaks
+   */
+  cleanupStaleStreams() {
+    try {
+      const now = Date.now();
+      const staleCutoff = now - this.STREAM_TIMEOUT_MS;
+      const staleStreams = [];
+      for (const [responseId, stream] of this.speakerStreams.entries()) {
+        const created = stream.created || 0;
+        if (created < staleCutoff) {
+          staleStreams.push(responseId);
+        }
+      }
+      if (staleStreams.length > 0) {
+        this.log(`Cleaning up ${staleStreams.length} stale streams`);
+        for (const responseId of staleStreams) {
+          const stream = this.speakerStreams.get(responseId);
+          if (stream && !stream.destroyed) {
+            stream.end();
+          }
+          this.speakerStreams.delete(responseId);
+        }
+      }
+    } catch (error) {
+      this.log("Error cleaning up stale streams:", error);
+    }
+  }
+  /**
+   * Enforce stream limits to prevent memory exhaustion
+   */
+  enforceStreamLimits() {
+    try {
+      if (this.speakerStreams.size <= this.MAX_CONCURRENT_STREAMS) {
+        return;
+      }
+      this.log(
+        `Stream limit exceeded (${this.speakerStreams.size}/${this.MAX_CONCURRENT_STREAMS}), cleaning up oldest streams`
+      );
+      const sortedStreams = Array.from(this.speakerStreams.entries()).sort(
+        ([, a], [, b]) => (a.created || 0) - (b.created || 0)
+      );
+      const streamsToRemove = sortedStreams.slice(0, this.speakerStreams.size - this.MAX_CONCURRENT_STREAMS);
+      for (const [responseId, stream] of streamsToRemove) {
+        if (!stream.destroyed) {
+          stream.end();
+        }
+        this.speakerStreams.delete(responseId);
+        this.log(`Removed old stream for response: ${responseId}`);
+      }
+    } catch (error) {
+      this.log("Error enforcing stream limits:", error);
+    }
+  }
+  /**
+   * Get information about current streams for debugging
+   */
+  getStreamInfo() {
+    const streamDetails = Array.from(this.speakerStreams.entries()).map(([responseId, stream]) => ({
+      responseId,
+      created: stream.created || 0,
+      destroyed: stream.destroyed
+    }));
+    return {
+      totalStreams: this.speakerStreams.size,
+      currentResponseId: this.currentResponseId,
+      streamDetails
+    };
+  }
+  /**
+   * Convert Int16Array audio data to base64 string for WebSocket transmission
+   */
+  int16ArrayToBase64(int16Array) {
+    const buffer = new ArrayBuffer(int16Array.length * 2);
+    const view = new DataView(buffer);
+    for (let i = 0; i < int16Array.length; i++) {
+      view.setInt16(i * 2, int16Array[i], true);
+    }
+    const nodeBuffer = Buffer.from(buffer);
+    return nodeBuffer.toString("base64");
+  }
+  /**
+   * Convert base64 string to Int16Array audio data
+   */
+  base64ToInt16Array(base64Audio) {
+    try {
+      const buffer = Buffer.from(base64Audio, "base64");
+      if (buffer.length % 2 !== 0) {
+        throw new Error("Invalid audio data: buffer length must be even for 16-bit audio");
+      }
+      return new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2);
+    } catch (error) {
+      throw new Error(
+        `Failed to decode base64 audio data: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Validate and convert audio data to the required format for Gemini Live API
+   * Gemini Live expects 16kHz PCM16 for input
+   */
+  validateAndConvertAudioInput(audioData) {
+    if (Buffer.isBuffer(audioData)) {
+      if (audioData.length % 2 !== 0) {
+        throw new Error("Audio buffer length must be even for 16-bit audio");
+      }
+      return new Int16Array(audioData.buffer, audioData.byteOffset, audioData.byteLength / 2);
+    }
+    if (audioData instanceof Int16Array) {
+      return audioData;
+    }
+    throw new Error("Unsupported audio data format. Expected Buffer or Int16Array");
+  }
+  /**
+   * Process audio chunk for streaming - handles format validation and conversion
+   */
+  processAudioChunk(chunk) {
+    let int16Array;
+    if (chunk instanceof Int16Array) {
+      int16Array = chunk;
+    } else if (Buffer.isBuffer(chunk)) {
+      if (chunk.length % 2 !== 0) {
+        throw new Error("Audio chunk length must be even for 16-bit audio");
+      }
+      int16Array = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.byteLength / 2);
+    } else if (chunk instanceof Uint8Array) {
+      if (chunk.length % 2 !== 0) {
+        throw new Error("Audio chunk length must be even for 16-bit audio");
+      }
+      int16Array = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.byteLength / 2);
+    } else {
+      throw new Error("Unsupported audio chunk format");
+    }
+    return this.int16ArrayToBase64(int16Array);
+  }
+  /**
+   * Validate audio format and sample rate for Gemini Live API requirements
+   */
+  validateAudioFormat(sampleRate, channels) {
+    if (sampleRate && sampleRate !== this.audioConfig.inputSampleRate) {
+      this.log(
+        `Warning: Audio sample rate ${sampleRate}Hz does not match expected ${this.audioConfig.inputSampleRate}Hz`
+      );
+    }
+    if (channels && channels !== this.audioConfig.channels) {
+      throw new Error(`Unsupported channel count: ${channels}. Gemini Live API requires mono audio (1 channel)`);
+    }
+  }
+  /**
+   * Create an audio message for the Gemini Live API
+   */
+  createAudioMessage(audioData, messageType = "realtime") {
+    if (messageType === "input") {
+      return {
+        client_content: {
+          turns: [
+            {
+              role: "user",
+              parts: [
+                {
+                  inlineData: {
+                    mimeType: "audio/pcm",
+                    data: audioData
+                  }
+                }
+              ]
+            }
+          ],
+          turnComplete: true
+        }
+      };
+    } else {
+      return {
+        realtime_input: {
+          media_chunks: [
+            {
+              mime_type: "audio/pcm",
+              data: audioData
+            }
+          ]
+        }
+      };
+    }
+  }
+  /**
+   * Get a speaker stream by response ID
+   */
+  getSpeakerStream(responseId) {
+    return this.speakerStreams.get(responseId);
+  }
+  /**
+   * Create a new speaker stream for a response ID
+   */
+  createSpeakerStream(responseId) {
+    const stream = new PassThrough();
+    stream.id = responseId;
+    stream.created = Date.now();
+    this.addSpeakerStream(responseId, stream);
+    return stream;
+  }
+  /**
+   * Get the number of active streams
+   */
+  getActiveStreamCount() {
+    return this.speakerStreams.size;
+  }
+  /**
+   * Check if a specific response ID has an active stream
+   */
+  hasStream(responseId) {
+    return this.speakerStreams.has(responseId);
+  }
+  /**
+   * Get all active response IDs
+   */
+  getActiveResponseIds() {
+    return Array.from(this.speakerStreams.keys());
+  }
+  /**
+   * Reset the manager state (useful for testing or reconnection)
+   */
+  reset() {
+    this.cleanupSpeakerStreams();
+    this.currentResponseId = void 0;
+    this.log("AudioStreamManager reset");
+  }
+  /**
+   * Validate audio chunk size and format
+   */
+  validateAudioChunk(chunk) {
+    if (chunk.length === 0) {
+      throw new Error("Audio chunk cannot be empty");
+    }
+    if (chunk.length > this.maxChunkSize) {
+      throw new Error(`Audio chunk size ${chunk.length} exceeds maximum allowed size ${this.maxChunkSize}`);
+    }
+    if (chunk.length % 2 !== 0) {
+      throw new Error("Audio chunk length must be even for 16-bit audio");
+    }
+  }
+  /**
+   * Send audio chunk with throttling and validation
+   */
+  sendAudioChunk(chunk) {
+    try {
+      this.validateAudioChunk(chunk);
+      const now = Date.now();
+      if (now - this.lastSendTime < this.minSendInterval) {
+        this.pendingChunks.push({ chunk, timestamp: now });
+        const delay = this.minSendInterval - (now - this.lastSendTime);
+        if (!this.pendingTimer) {
+          this.pendingTimer = setTimeout(
+            () => {
+              this.pendingTimer = void 0;
+              this.processPendingChunks();
+            },
+            Math.max(0, delay)
+          );
+        }
+        return;
+      }
+      this.processChunk(chunk);
+      this.processPendingChunks();
+    } catch (error) {
+      this.log("Error sending audio chunk:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle audio stream processing
+   */
+  async handleAudioStream(stream) {
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        stream.removeAllListeners();
+      };
+      stream.on("data", (chunk) => {
+        try {
+          if (chunk.length > this.maxChunkSize) {
+            const chunks = this.splitAudioChunk(chunk);
+            for (const subChunk of chunks) {
+              this.validateAudioChunk(subChunk);
+              this.sendAudioChunk(subChunk);
+            }
+          } else {
+            this.validateAudioChunk(chunk);
+            this.sendAudioChunk(chunk);
+          }
+        } catch (error) {
+          cleanup();
+          reject(error);
+        }
+      });
+      stream.on("end", () => {
+        cleanup();
+        resolve();
+      });
+      stream.on("error", (error) => {
+        cleanup();
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Split large audio chunks into smaller ones
+   */
+  splitAudioChunk(chunk) {
+    const chunks = [];
+    let offset = 0;
+    while (offset < chunk.length) {
+      const size = Math.min(this.maxChunkSize, chunk.length - offset);
+      chunks.push(chunk.subarray(offset, offset + size));
+      offset += size;
+    }
+    return chunks;
+  }
+  /**
+   * Calculate audio duration from buffer length
+   */
+  calculateAudioDuration(bufferLength, sampleRate) {
+    const effectiveSampleRate = sampleRate || this.audioConfig.inputSampleRate;
+    return bufferLength / (effectiveSampleRate * 2);
+  }
+  /**
+   * Validate audio buffer size and duration
+   */
+  validateAudioBuffer(buffer) {
+    if (buffer.length === 0) {
+      throw new Error("Audio buffer cannot be empty");
+    }
+    if (buffer.length > this.MAX_BUFFER_SIZE) {
+      throw new Error(
+        `Audio buffer size ${buffer.length} exceeds maximum allowed size ${this.MAX_BUFFER_SIZE / (1024 * 1024)}MB`
+      );
+    }
+    if (buffer.length % 2 !== 0) {
+      throw new Error("Audio buffer length must be even for 16-bit audio");
+    }
+    const duration = this.calculateAudioDuration(buffer.length);
+    if (duration > this.MAX_AUDIO_DURATION) {
+      throw new Error(
+        `Audio duration ${duration.toFixed(2)}s exceeds maximum allowed duration ${this.MAX_AUDIO_DURATION}s`
+      );
+    }
+  }
+  /**
+   * Process audio buffer for transcription
+   * Combines chunks, validates format, and converts to base64
+   */
+  processAudioBufferForTranscription(audioBuffer) {
+    if (audioBuffer.length % 2 !== 0) {
+      throw new Error("Invalid audio data: buffer length must be even for 16-bit audio");
+    }
+    const duration = this.calculateAudioDuration(audioBuffer.length);
+    const base64Audio = audioBuffer.toString("base64");
+    return {
+      base64Audio,
+      duration,
+      size: audioBuffer.length
+    };
+  }
+  /**
+   * Process audio chunks for transcription with buffer management
+   * Handles chunk collection, size validation, and buffer management
+   */
+  processAudioChunksForTranscription(chunks, totalBufferSize) {
+    if (totalBufferSize > this.MAX_BUFFER_SIZE) {
+      throw new Error(`Audio data exceeds maximum size of ${this.MAX_BUFFER_SIZE / (1024 * 1024)}MB`);
+    }
+    const audioBuffer = Buffer.concat(chunks);
+    const result = this.processAudioBufferForTranscription(audioBuffer);
+    return {
+      audioBuffer,
+      ...result
+    };
+  }
+  /**
+   * Validate audio chunks and calculate total size
+   */
+  validateAudioChunks(chunks) {
+    let totalSize = 0;
+    for (const chunk of chunks) {
+      if (!Buffer.isBuffer(chunk)) {
+        return { totalSize: 0, isValid: false, error: "Invalid chunk format" };
+      }
+      totalSize += chunk.length;
+      if (totalSize > this.MAX_BUFFER_SIZE) {
+        return {
+          totalSize,
+          isValid: false,
+          error: `Total size ${totalSize} exceeds maximum allowed size ${this.MAX_BUFFER_SIZE}`
+        };
+      }
+    }
+    return { totalSize, isValid: true };
+  }
+  /**
+   * Get audio buffer limits and configuration
+   */
+  getAudioBufferLimits() {
+    return {
+      maxBufferSize: this.MAX_BUFFER_SIZE,
+      maxAudioDuration: this.MAX_AUDIO_DURATION,
+      maxChunkSize: this.maxChunkSize
+    };
+  }
+  /**
+   * Get audio configuration
+   */
+  getAudioConfig() {
+    return this.audioConfig;
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, ...args) {
+    if (this.debug) {
+      console.log(`[AudioStreamManager] ${message}`, ...args);
+    }
+  }
+  /**
+   * Handle complete audio transcription workflow
+   * Manages stream processing, chunk collection, and transcription
+   */
+  async handleAudioTranscription(audioStream, sendAndAwaitTranscript, onError, timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let isCleanedUp = false;
+      let totalBufferSize = 0;
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          cleanup();
+          reject(new Error(`Transcription timeout - no response received within ${timeoutMs / 1e3} seconds`));
+        }
+      }, timeoutMs);
+      const onStreamData = (chunk) => {
+        try {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          totalBufferSize += buffer.length;
+          if (totalBufferSize > this.MAX_BUFFER_SIZE) {
+            cleanup();
+            reject(new Error(`Audio data exceeds maximum size of ${this.MAX_BUFFER_SIZE / (1024 * 1024)}MB`));
+            return;
+          }
+          chunks.push(buffer);
+        } catch (error) {
+          cleanup();
+          reject(
+            new Error(`Failed to process audio chunk: ${error instanceof Error ? error.message : "Unknown error"}`)
+          );
+        }
+      };
+      const onStreamError = (error) => {
+        cleanup();
+        reject(new Error(`Audio stream error: ${error.message}`));
+      };
+      const onStreamEnd = async () => {
+        try {
+          audioStream.removeListener("data", onStreamData);
+          audioStream.removeListener("error", onStreamError);
+          const result = this.processAudioChunksForTranscription(chunks, totalBufferSize);
+          this.log("Processing audio for transcription:", {
+            chunks: chunks.length,
+            totalSize: result.size,
+            duration: result.duration
+          });
+          try {
+            const transcript = await sendAndAwaitTranscript(result.base64Audio);
+            if (!isResolved) {
+              isResolved = true;
+              cleanup();
+              resolve(transcript.trim());
+            }
+          } catch (error) {
+            if (!isResolved) {
+              isResolved = true;
+              cleanup();
+              reject(
+                new Error(
+                  `Failed to obtain transcription: ${error instanceof Error ? error.message : "Unknown error"}`
+                )
+              );
+            }
+          }
+        } catch (error) {
+          cleanup();
+          reject(
+            new Error(`Failed to process audio stream: ${error instanceof Error ? error.message : "Unknown error"}`)
+          );
+        }
+      };
+      const cleanup = () => {
+        if (isCleanedUp) return;
+        isCleanedUp = true;
+        clearTimeout(timeout);
+        audioStream.removeListener("data", onStreamData);
+        audioStream.removeListener("error", onStreamError);
+        audioStream.removeListener("end", onStreamEnd);
+        chunks.length = 0;
+      };
+      audioStream.on("data", onStreamData);
+      audioStream.on("error", onStreamError);
+      audioStream.on("end", onStreamEnd);
+    });
+  }
+  processChunk(chunk) {
+    const base64Audio = this.processAudioChunk(chunk);
+    const message = this.createAudioMessage(base64Audio, "realtime");
+    if (this.sendToGemini) {
+      this.sendToGemini("realtime_input", message);
+    } else {
+      this.log("No sender configured for AudioStreamManager; dropping audio chunk");
+    }
+    this.lastSendTime = Date.now();
+    this.log(`Sent audio chunk of size: ${chunk.length} bytes`);
+  }
+  processPendingChunks() {
+    while (this.pendingChunks.length > 0) {
+      const nextChunk = this.pendingChunks[0];
+      const now = Date.now();
+      if (nextChunk && now - this.lastSendTime >= this.minSendInterval) {
+        this.pendingChunks.shift();
+        this.processChunk(nextChunk.chunk);
+      } else {
+        const delay = this.minSendInterval - (now - this.lastSendTime);
+        if (!this.pendingTimer) {
+          this.pendingTimer = setTimeout(
+            () => {
+              this.pendingTimer = void 0;
+              this.processPendingChunks();
+            },
+            Math.max(0, delay)
+          );
+        }
+        break;
+      }
+    }
+  }
+};
+
+// src/utils/errors.ts
+var GeminiLiveError = class extends Error {
+  code;
+  details;
+  timestamp;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "GeminiLiveError";
+    this.code = code;
+    this.details = details;
+    this.timestamp = Date.now();
+  }
+  toEventData() {
+    return {
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      timestamp: this.timestamp
+    };
+  }
+};
+
+// src/managers/ConnectionManager.ts
+var ConnectionManager = class {
+  ws;
+  eventEmitter;
+  debug;
+  timeoutMs;
+  constructor(config) {
+    this.eventEmitter = new EventEmitter();
+    this.debug = config.debug;
+    this.timeoutMs = config.timeoutMs || 3e4;
+  }
+  /**
+   * Set the WebSocket instance
+   */
+  setWebSocket(ws) {
+    this.ws = ws;
+  }
+  /**
+   * Get the current WebSocket instance
+   */
+  getWebSocket() {
+    return this.ws;
+  }
+  /**
+   * Check if WebSocket is connected
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Check if WebSocket is connecting
+   */
+  isConnecting() {
+    return this.ws?.readyState === WebSocket.CONNECTING;
+  }
+  /**
+   * Check if WebSocket is closed
+   */
+  isClosed() {
+    return this.ws?.readyState === WebSocket.CLOSED;
+  }
+  /**
+   * Wait for WebSocket to open
+   */
+  async waitForOpen() {
+    return new Promise((resolve, reject) => {
+      if (!this.ws) {
+        reject(new Error("WebSocket not initialized"));
+        return;
+      }
+      if (this.ws.readyState === WebSocket.OPEN) {
+        resolve();
+        return;
+      }
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(new Error(`WebSocket connection failed: ${error.message}`));
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("WebSocket connection closed before opening"));
+      };
+      const cleanup = () => {
+        this.ws?.removeListener("open", onOpen);
+        this.ws?.removeListener("error", onError);
+        this.ws?.removeListener("close", onClose);
+      };
+      this.ws.once("open", onOpen);
+      this.ws.once("error", onError);
+      this.ws.once("close", onClose);
+      setTimeout(() => {
+        cleanup();
+        reject(new GeminiLiveError("connection_failed" /* CONNECTION_FAILED */, "WebSocket connection timeout"));
+      }, this.timeoutMs);
+    });
+  }
+  /**
+   * Send data through WebSocket
+   */
+  send(data) {
+    if (!this.ws) {
+      throw new GeminiLiveError("connection_not_established" /* CONNECTION_NOT_ESTABLISHED */, "WebSocket not initialized");
+    }
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      throw new GeminiLiveError("connection_not_established" /* CONNECTION_NOT_ESTABLISHED */, "WebSocket is not open");
+    }
+    this.ws.send(data);
+  }
+  /**
+   * Close the WebSocket connection
+   */
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = void 0;
+    }
+  }
+  /**
+   * Get connection state
+   */
+  getConnectionState() {
+    if (!this.ws) return "disconnected";
+    switch (this.ws.readyState) {
+      case WebSocket.CONNECTING:
+        return "connecting";
+      case WebSocket.OPEN:
+        return "connected";
+      case WebSocket.CLOSED:
+        return "closed";
+      default:
+        return "disconnected";
+    }
+  }
+  /**
+   * Validate WebSocket state for operations
+   */
+  validateWebSocketState() {
+    if (!this.ws) {
+      throw new GeminiLiveError("connection_not_established" /* CONNECTION_NOT_ESTABLISHED */, "WebSocket not initialized");
+    }
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      throw new GeminiLiveError("connection_not_established" /* CONNECTION_NOT_ESTABLISHED */, "WebSocket is not open");
+    }
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, ...args) {
+    if (this.debug) {
+      console.log(`[ConnectionManager] ${message}`, ...args);
+    }
+  }
+};
+
+// src/managers/ContextManager.ts
+var ContextManager = class {
+  contextHistory = [];
+  maxEntries;
+  maxContentLength;
+  compressionThreshold;
+  compressionEnabled;
+  constructor(config = {}) {
+    this.maxEntries = config.maxEntries || 100;
+    this.maxContentLength = config.maxContentLength || 1e4;
+    this.compressionThreshold = config.compressionThreshold || 50;
+    this.compressionEnabled = config.compressionEnabled ?? false;
+  }
+  /**
+   * Add entry to context history
+   */
+  addEntry(role, content) {
+    let processedContent = content;
+    if (content.length > this.maxContentLength) {
+      processedContent = content.substring(0, this.maxContentLength) + "...";
+    }
+    const entry = {
+      role,
+      content: processedContent,
+      timestamp: Date.now()
+    };
+    this.contextHistory.push(entry);
+    if (this.contextHistory.length > this.maxEntries) {
+      if (this.compressionEnabled) {
+        this.compressContext();
+      } else {
+        this.contextHistory = this.contextHistory.slice(-this.maxEntries);
+      }
+    }
+  }
+  /**
+   * Get context history
+   */
+  getContextHistory() {
+    return [...this.contextHistory];
+  }
+  /**
+   * Get context history as array of role/content pairs
+   */
+  getContextArray() {
+    return this.contextHistory.map((entry) => ({
+      role: entry.role,
+      content: entry.content
+    }));
+  }
+  /**
+   * Clear context history
+   */
+  clearContext() {
+    this.contextHistory = [];
+  }
+  /**
+   * Get context size
+   */
+  getContextSize() {
+    return this.contextHistory.length;
+  }
+  /**
+   * Compress context when it exceeds threshold
+   */
+  compressContext() {
+    if (!this.compressionEnabled || this.contextHistory.length <= this.compressionThreshold) {
+      return;
+    }
+    const keepCount = Math.floor(this.compressionThreshold / 3);
+    const firstEntries = this.contextHistory.slice(0, keepCount);
+    const lastEntries = this.contextHistory.slice(-keepCount);
+    const middleEntries = this.contextHistory.slice(keepCount, -keepCount);
+    if (middleEntries.length > 0) {
+      const compressedEntry = {
+        role: "assistant",
+        content: `[Compressed ${middleEntries.length} previous messages]`,
+        timestamp: Date.now()
+      };
+      this.contextHistory = [...firstEntries, compressedEntry, ...lastEntries];
+    } else {
+      this.contextHistory = [...firstEntries, ...lastEntries];
+    }
+  }
+  /**
+   * Enable or disable compression at runtime
+   */
+  setCompressionEnabled(enabled) {
+    this.compressionEnabled = enabled;
+  }
+  /**
+   * Get context summary
+   */
+  getContextSummary() {
+    if (this.contextHistory.length === 0) {
+      return {
+        totalEntries: 0,
+        userEntries: 0,
+        assistantEntries: 0,
+        oldestTimestamp: null,
+        newestTimestamp: null
+      };
+    }
+    const userEntries = this.contextHistory.filter((entry) => entry.role === "user").length;
+    const assistantEntries = this.contextHistory.filter((entry) => entry.role === "assistant").length;
+    const timestamps = this.contextHistory.map((entry) => entry.timestamp);
+    return {
+      totalEntries: this.contextHistory.length,
+      userEntries,
+      assistantEntries,
+      oldestTimestamp: Math.min(...timestamps),
+      newestTimestamp: Math.max(...timestamps)
+    };
+  }
+  /**
+   * Search context for specific content
+   */
+  searchContext(query, role) {
+    const searchQuery = query.toLowerCase();
+    return this.contextHistory.filter((entry) => {
+      const matchesRole = role ? entry.role === role : true;
+      const matchesContent = entry.content.toLowerCase().includes(searchQuery);
+      return matchesRole && matchesContent;
+    });
+  }
+  /**
+   * Get recent context entries
+   */
+  getRecentEntries(count) {
+    return this.contextHistory.slice(-count);
+  }
+  /**
+   * Get context entries by role
+   */
+  getEntriesByRole(role) {
+    return this.contextHistory.filter((entry) => entry.role === role);
+  }
+};
+var AuthManager = class {
+  authClient;
+  accessToken;
+  tokenExpirationTime;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.tokenExpirationTime = config.tokenExpirationTime ?? 50 * 60 * 1e3;
+  }
+  /**
+   * Initialize authentication based on configuration
+   */
+  async initialize() {
+    if (this.config.vertexAI) {
+      await this.initializeVertexAI();
+    } else if (this.config.apiKey) {
+      return;
+    } else {
+      throw new GeminiLiveError(
+        "api_key_missing" /* API_KEY_MISSING */,
+        "Either API key or Vertex AI configuration is required"
+      );
+    }
+  }
+  /**
+   * Initialize Vertex AI authentication
+   */
+  async initializeVertexAI() {
+    if (!this.config.project) {
+      throw new GeminiLiveError(
+        "project_id_missing" /* PROJECT_ID_MISSING */,
+        "Google Cloud project ID is required when using Vertex AI"
+      );
+    }
+    const authOptions = {
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+      projectId: this.config.project
+    };
+    if (this.config.serviceAccountKeyFile) {
+      authOptions.keyFilename = this.config.serviceAccountKeyFile;
+      this.log("Using service account key file for authentication:", this.config.serviceAccountKeyFile);
+    }
+    if (this.config.serviceAccountEmail) {
+      authOptions.clientOptions = { subject: this.config.serviceAccountEmail };
+      this.log("Using service account impersonation:", this.config.serviceAccountEmail);
+    }
+    try {
+      this.authClient = new GoogleAuth(authOptions);
+    } catch (error) {
+      throw new GeminiLiveError(
+        "authentication_failed" /* AUTHENTICATION_FAILED */,
+        `Failed to initialize Vertex AI authentication: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Get access token for Vertex AI
+   */
+  async getAccessToken() {
+    if (!this.config.vertexAI) {
+      throw new GeminiLiveError("authentication_failed" /* AUTHENTICATION_FAILED */, "Vertex AI authentication not configured");
+    }
+    if (!this.authClient) {
+      throw new GeminiLiveError("authentication_failed" /* AUTHENTICATION_FAILED */, "Authentication client not initialized");
+    }
+    if (this.accessToken && this.tokenExpirationTime && Date.now() < this.tokenExpirationTime) {
+      return this.accessToken;
+    }
+    try {
+      const client = await this.authClient.getClient();
+      const token = await client.getAccessToken();
+      if (!token.token) {
+        throw new Error("No access token received");
+      }
+      this.accessToken = token.token;
+      this.tokenExpirationTime = Date.now() + 50 * 60 * 1e3;
+      this.log("Successfully obtained new access token");
+      return this.accessToken;
+    } catch (error) {
+      throw new GeminiLiveError(
+        "authentication_failed" /* AUTHENTICATION_FAILED */,
+        `Failed to get access token: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Get API key if using API key authentication
+   */
+  getApiKey() {
+    if (this.config.vertexAI) {
+      return void 0;
+    }
+    return this.config.apiKey;
+  }
+  /**
+   * Check if using Vertex AI authentication
+   */
+  isUsingVertexAI() {
+    return this.config.vertexAI === true;
+  }
+  /**
+   * Check if authentication is configured
+   */
+  isConfigured() {
+    return !!(this.config.apiKey || this.config.vertexAI && this.config.project);
+  }
+  /**
+   * Check if access token is valid
+   */
+  hasValidToken() {
+    if (!this.config.vertexAI) return false;
+    return !!(this.accessToken && this.tokenExpirationTime && Date.now() < this.tokenExpirationTime);
+  }
+  /**
+   * Clear cached authentication data
+   */
+  clearCache() {
+    this.accessToken = void 0;
+    this.tokenExpirationTime = void 0;
+  }
+  /**
+   * Get authentication configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[AuthManager] ${message}`, ...args);
+    }
+  }
+};
+var EventManager = class {
+  eventEmitter;
+  debug;
+  eventCounts = {};
+  constructor(config) {
+    this.eventEmitter = new EventEmitter();
+    this.debug = config.debug;
+  }
+  /**
+   * Emit an event with data
+   */
+  emit(event, data) {
+    this.incrementEventCount(event);
+    const result = this.eventEmitter.emit(event, data);
+    if (this.debug) {
+      this.log(`Emitted event: ${event}`, data);
+    }
+    return result;
+  }
+  /**
+   * Add event listener
+   */
+  on(event, callback) {
+    this.eventEmitter.on(event, callback);
+    if (this.debug) {
+      this.log(`Added listener for event: ${event}`);
+    }
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    this.eventEmitter.off(event, callback);
+    if (this.debug) {
+      this.log(`Removed listener for event: ${event}`);
+    }
+  }
+  /**
+   * Add one-time event listener
+   */
+  once(event, callback) {
+    this.eventEmitter.once(event, callback);
+    if (this.debug) {
+      this.log(`Added one-time listener for event: ${event}`);
+    }
+  }
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event) {
+    this.eventEmitter.removeAllListeners(event);
+    if (this.debug) {
+      this.log(`Removed all listeners${event ? ` for event: ${event}` : ""}`);
+    }
+  }
+  /**
+   * Get event listener count
+   */
+  getListenerCount(event) {
+    return this.eventEmitter.listenerCount(event);
+  }
+  /**
+   * Get event listener info
+   */
+  getEventListenerInfo() {
+    const events = this.eventEmitter.eventNames();
+    const info = {};
+    events.forEach((event) => {
+      const eventName = typeof event === "string" ? event : event.toString();
+      info[eventName] = this.eventEmitter.listenerCount(event);
+    });
+    return info;
+  }
+  /**
+   * Get event emission counts
+   */
+  getEventCounts() {
+    return { ...this.eventCounts };
+  }
+  /**
+   * Reset event counts
+   */
+  resetEventCounts() {
+    this.eventCounts = {};
+  }
+  /**
+   * Clean up event listeners
+   */
+  cleanup() {
+    this.eventEmitter.removeAllListeners();
+    this.resetEventCounts();
+    if (this.debug) {
+      this.log("Cleaned up all event listeners");
+    }
+  }
+  /**
+   * Get the underlying EventEmitter
+   */
+  getEventEmitter() {
+    return this.eventEmitter;
+  }
+  /**
+   * Increment event count for tracking
+   */
+  incrementEventCount(event) {
+    this.eventCounts[event] = (this.eventCounts[event] || 0) + 1;
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, ...args) {
+    if (this.debug) {
+      console.log(`[EventManager] ${message}`, ...args);
+    }
+  }
+};
+
+// src/index.ts
+var DEFAULT_MODEL = "gemini-2.0-flash-exp";
+var DEFAULT_VOICE = "Puck";
+var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
+  ws;
+  eventManager;
+  state = "disconnected";
+  sessionHandle;
+  debug;
+  audioConfig;
+  queue = [];
+  // Managers
+  connectionManager;
+  contextManager;
+  authManager;
+  // Audio chunk concatenation - optimized stream management
+  audioStreamManager;
+  // Session management properties
+  sessionId;
+  sessionStartTime;
+  isResuming = false;
+  sessionDurationTimeout;
+  // Tool integration properties
+  tools;
+  runtimeContext;
+  // Store the configuration options
+  options;
+  /**
+   * Normalize configuration to ensure proper VoiceConfig format
+   * Handles backward compatibility with direct GeminiLiveVoiceConfig
+   * @private
+   */
+  static normalizeConfig(config) {
+    if ("realtimeConfig" in config || "speechModel" in config || "listeningModel" in config) {
+      return config;
+    }
+    const geminiConfig = config;
+    return {
+      speechModel: {
+        name: geminiConfig.model || DEFAULT_MODEL,
+        apiKey: geminiConfig.apiKey
+      },
+      speaker: geminiConfig.speaker || DEFAULT_VOICE,
+      realtimeConfig: {
+        model: geminiConfig.model || DEFAULT_MODEL,
+        apiKey: geminiConfig.apiKey,
+        options: geminiConfig
+      }
+    };
+  }
+  /**
+   * Creates a new GeminiLiveVoice instance
+   *
+   * @param config Configuration options
+   */
+  constructor(config = {}) {
+    const normalizedConfig = _GeminiLiveVoice.normalizeConfig(config);
+    super(normalizedConfig);
+    this.options = normalizedConfig.realtimeConfig?.options || {};
+    const apiKey = this.options.apiKey;
+    if (!apiKey && !this.options.vertexAI) {
+      throw new GeminiLiveError(
+        "api_key_missing" /* API_KEY_MISSING */,
+        "Google API key is required. Set GOOGLE_API_KEY environment variable or pass apiKey to constructor"
+      );
+    }
+    this.debug = this.options.debug || false;
+    this.audioConfig = {
+      ...AudioStreamManager.getDefaultAudioConfig(),
+      ...this.options.audioConfig
+    };
+    this.audioStreamManager = new AudioStreamManager(this.audioConfig, this.debug);
+    this.audioStreamManager.setSender((type, message) => this.sendEvent(type, message));
+    this.eventManager = new EventManager({ debug: this.debug });
+    this.connectionManager = new ConnectionManager({ debug: this.debug, timeoutMs: 3e4 });
+    this.contextManager = new ContextManager({
+      maxEntries: 100,
+      compressionThreshold: 50,
+      compressionEnabled: this.options.sessionConfig?.contextCompression ?? false
+    });
+    this.authManager = new AuthManager({
+      apiKey: this.options.apiKey,
+      vertexAI: this.options.vertexAI,
+      project: this.options.project,
+      serviceAccountKeyFile: this.options.serviceAccountKeyFile,
+      serviceAccountEmail: this.options.serviceAccountEmail,
+      debug: this.debug,
+      tokenExpirationTime: this.options.tokenExpirationTime
+    });
+    if (this.options.vertexAI && !this.options.project) {
+      throw new GeminiLiveError(
+        "project_id_missing" /* PROJECT_ID_MISSING */,
+        "Google Cloud project ID is required when using Vertex AI. Set GOOGLE_CLOUD_PROJECT environment variable or pass project to constructor"
+      );
+    }
+  }
+  /**
+   * Register an event listener
+   * @param event Event name (e.g., 'speaking', 'writing', 'error', 'speaker')
+   * @param callback Callback function that receives event data
+   *
+   * @example
+   * ```typescript
+   * // Listen for audio responses
+   * voice.on('speaking', ({ audio, audioData, sampleRate }) => {
+   *   console.log('Received audio chunk:', audioData.length);
+   * });
+   *
+   * // Listen for text responses and transcriptions
+   * voice.on('writing', ({ text, role }) => {
+   *   console.log(`${role}: ${text}`);
+   * });
+   *
+   * // Listen for audio streams (for concatenated playback)
+   * voice.on('speaker', (audioStream) => {
+   *   audioStream.pipe(playbackDevice);
+   * });
+   *
+   * // Handle errors
+   * voice.on('error', ({ message, code, details }) => {
+   *   console.error('Voice error:', message);
+   * });
+   * ```
+   */
+  on(event, callback) {
+    try {
+      this.eventManager.on(event, callback);
+      this.log(`Event listener registered for: ${event}`);
+    } catch (error) {
+      this.log(`Failed to register event listener for ${event}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Remove an event listener
+   * @param event Event name
+   * @param callback Callback function to remove
+   */
+  off(event, callback) {
+    try {
+      this.eventManager.off(event, callback);
+      this.log(`Event listener removed for: ${event}`);
+    } catch (error) {
+      this.log(`Failed to remove event listener for ${event}:`, error);
+    }
+  }
+  /**
+   * Register a one-time event listener that automatically removes itself after the first emission
+   * @param event Event name
+   * @param callback Callback function that receives event data
+   */
+  once(event, callback) {
+    try {
+      this.eventManager.once(event, callback);
+      this.log(`One-time event listener registered for: ${event}`);
+    } catch (error) {
+      this.log(`Failed to register one-time event listener for ${event}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Emit an event to listeners with improved error handling
+   * @private
+   */
+  emit(event, data) {
+    try {
+      const listenerCount = this.eventManager.getListenerCount(event);
+      if (listenerCount === 0 && this.debug) {
+        this.log(`No listeners for event: ${String(event)}`);
+      }
+      const result = this.eventManager.emit(event, data);
+      if (this.debug && listenerCount > 0) {
+        this.log(`Emitted event: ${String(event)} to ${listenerCount} listeners`);
+      }
+      return result;
+    } catch (error) {
+      this.log(`Error emitting event ${String(event)}:`, error);
+      if (event !== "error") {
+        try {
+          this.eventManager.getEventEmitter().emit("error", {
+            message: `Failed to emit event: ${String(event)}`,
+            code: "event_emission_error",
+            details: error
+          });
+        } catch (nestedError) {
+          this.log("Critical: Failed to emit error event:", nestedError);
+        }
+      }
+      return false;
+    }
+  }
+  /**
+   * Clean up event listeners to prevent memory leaks
+   * @private
+   */
+  cleanupEventListeners() {
+    try {
+      const events = this.eventManager.getEventEmitter().eventNames();
+      if (this.debug && events.length > 0) {
+        this.log(
+          "Cleaning up event listeners:",
+          events.map((event) => `${String(event)}: ${this.eventManager.getListenerCount(String(event))}`).join(", ")
+        );
+      }
+      this.eventManager.cleanup();
+      this.log("Event listeners cleaned up");
+    } catch (error) {
+      this.log("Error cleaning up event listeners:", error);
+    }
+  }
+  /**
+   * Get current event listener information for debugging
+   * @returns Object with event names and listener counts
+   */
+  getEventListenerInfo() {
+    try {
+      return this.eventManager.getEventListenerInfo();
+    } catch (error) {
+      this.log("Error getting event listener info:", error);
+      return {};
+    }
+  }
+  /**
+   * Create and emit a standardized error
+   * @private
+   */
+  createAndEmitError(code, message, details) {
+    const error = new GeminiLiveError(code, message, details);
+    this.log(`Error [${code}]: ${message}`, details);
+    this.emit("error", error.toEventData());
+    return error;
+  }
+  /**
+   * Handle connection state validation with standardized errors
+   * @private
+   */
+  validateConnectionState() {
+    if (this.state !== "connected") {
+      throw this.createAndEmitError(
+        "not_connected" /* NOT_CONNECTED */,
+        "Not connected to Gemini Live API. Call connect() first.",
+        { currentState: this.state }
+      );
+    }
+  }
+  /**
+   * Handle WebSocket state validation with standardized errors
+   * @private
+   */
+  validateWebSocketState() {
+    if (!this.connectionManager.isConnected()) {
+      throw this.createAndEmitError("websocket_error" /* WEBSOCKET_ERROR */, "WebSocket is not open", {
+        wsExists: !!this.connectionManager.getWebSocket(),
+        readyState: this.connectionManager.getWebSocket()?.readyState,
+        expectedState: WebSocket.OPEN
+      });
+    }
+  }
+  /**
+   * Establish connection to the Gemini Live API
+   */
+  async connect({ runtimeContext } = {}) {
+    return this.traced(async () => {
+      if (this.state === "connected") {
+        this.log("Already connected to Gemini Live API");
+        return;
+      }
+      this.runtimeContext = runtimeContext;
+      this.emit("session", { state: "connecting" });
+      try {
+        let wsUrl;
+        let headers = {};
+        if (this.options.vertexAI) {
+          wsUrl = `wss://${this.options.location}-aiplatform.googleapis.com/ws/google.cloud.aiplatform.v1beta1.PredictionService.ServerStreamingPredict`;
+          await this.authManager.initialize();
+          const accessToken = await this.authManager.getAccessToken();
+          headers = { headers: { Authorization: `Bearer ${accessToken}` } };
+          this.log("Using Vertex AI authentication with OAuth token");
+        } else {
+          wsUrl = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent`;
+          headers = {
+            headers: {
+              "x-goog-api-key": this.options.apiKey || "",
+              "Content-Type": "application/json"
+            }
+          };
+          this.log("Using Live API authentication with API key");
+        }
+        this.log("Connecting to:", wsUrl);
+        this.ws = new WebSocket(wsUrl, void 0, headers);
+        this.connectionManager.setWebSocket(this.ws);
+        this.setupEventListeners();
+        await this.connectionManager.waitForOpen();
+        if (this.isResuming && this.sessionHandle) {
+          await this.sendSessionResumption();
+        } else {
+          this.sendInitialConfig();
+          this.sessionStartTime = Date.now();
+          this.sessionId = randomUUID();
+        }
+        await this.waitForSessionCreated();
+        this.state = "connected";
+        this.emit("session", {
+          state: "connected",
+          config: {
+            sessionId: this.sessionId,
+            isResuming: this.isResuming,
+            toolCount: Object.keys(this.tools || {}).length
+          }
+        });
+        this.log("Successfully connected to Gemini Live API", {
+          sessionId: this.sessionId,
+          isResuming: this.isResuming,
+          toolCount: Object.keys(this.tools || {}).length
+        });
+        if (this.options.sessionConfig?.maxDuration) {
+          this.startSessionDurationMonitor();
+        }
+      } catch (error) {
+        this.state = "disconnected";
+        this.log("Connection failed", error);
+        throw error;
+      }
+    }, "gemini-live.connect")();
+  }
+  /**
+   * Disconnect from the Gemini Live API
+   */
+  async disconnect() {
+    if (this.state === "disconnected") {
+      this.log("Already disconnected");
+      return;
+    }
+    this.emit("session", { state: "disconnecting" });
+    if (this.sessionDurationTimeout) {
+      clearTimeout(this.sessionDurationTimeout);
+      this.sessionDurationTimeout = void 0;
+    }
+    if (this.options.sessionConfig?.enableResumption && this.sessionId) {
+      this.sessionHandle = this.sessionId;
+      this.log("Session handle saved for resumption", { handle: this.sessionHandle });
+    }
+    if (this.ws) {
+      this.connectionManager.close();
+      this.ws = void 0;
+    }
+    this.audioStreamManager.cleanupSpeakerStreams();
+    this.authManager.clearCache();
+    this.state = "disconnected";
+    this.isResuming = false;
+    this.emit("session", { state: "disconnected" });
+    this.cleanupEventListeners();
+    this.log("Disconnected from Gemini Live API", {
+      sessionId: this.sessionId,
+      sessionDuration: this.sessionStartTime ? Date.now() - this.sessionStartTime : void 0
+    });
+  }
+  /**
+   * Send text to be converted to speech
+   */
+  async speak(input, options) {
+    return this.traced(async () => {
+      this.validateConnectionState();
+      if (typeof input !== "string") {
+        const chunks = [];
+        for await (const chunk of input) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        }
+        input = Buffer.concat(chunks).toString("utf-8");
+      }
+      if (input.trim().length === 0) {
+        throw this.createAndEmitError("invalid_audio_format" /* INVALID_AUDIO_FORMAT */, "Input text is empty");
+      }
+      this.addToContext("user", input);
+      const textMessage = {
+        client_content: {
+          turns: [
+            {
+              role: "user",
+              parts: [
+                {
+                  text: input
+                }
+              ]
+            }
+          ],
+          turnComplete: true
+        }
+      };
+      if (options && (options.speaker || options.languageCode || options.responseModalities)) {
+        const updateMessage = {
+          type: "session.update",
+          session: {
+            generation_config: {
+              ...options.responseModalities ? { response_modalities: options.responseModalities } : {},
+              speech_config: {
+                ...options.languageCode ? { language_code: options.languageCode } : {},
+                ...options.speaker ? { voice_config: { prebuilt_voice_config: { voice_name: options.speaker } } } : {}
+              }
+            }
+          }
+        };
+        try {
+          this.sendEvent("session.update", updateMessage);
+          this.log("Applied per-turn runtime options", options);
+        } catch (error) {
+          this.log("Failed to apply per-turn runtime options", error);
+        }
+      }
+      try {
+        this.sendEvent("client_content", textMessage);
+        this.log("Text message sent", { text: input });
+      } catch (error) {
+        this.log("Failed to send text message", error);
+        throw this.createAndEmitError("audio_processing_error" /* AUDIO_PROCESSING_ERROR */, "Failed to send text message", error);
+      }
+    }, "gemini-live.speak")();
+  }
+  /**
+   * Send audio stream for processing
+   */
+  async send(audioData) {
+    return this.traced(async () => {
+      this.validateConnectionState();
+      if ("readable" in audioData && typeof audioData.on === "function") {
+        const stream = audioData;
+        stream.on("data", (chunk) => {
+          try {
+            const base64Audio = this.audioStreamManager.processAudioChunk(chunk);
+            const message = this.audioStreamManager.createAudioMessage(base64Audio, "realtime");
+            this.sendEvent("realtime_input", message);
+          } catch (error) {
+            this.log("Failed to process audio chunk", error);
+            this.createAndEmitError("audio_processing_error" /* AUDIO_PROCESSING_ERROR */, "Failed to process audio chunk", error);
+          }
+        });
+        stream.on("error", (error) => {
+          this.log("Audio stream error", error);
+          this.createAndEmitError("audio_stream_error" /* AUDIO_STREAM_ERROR */, "Audio stream error", error);
+        });
+        stream.on("end", () => {
+          this.log("Audio stream ended");
+        });
+      } else {
+        const validateAudio = this.audioStreamManager.validateAndConvertAudioInput(audioData);
+        const base64Audio = this.audioStreamManager.int16ArrayToBase64(validateAudio);
+        const message = this.audioStreamManager.createAudioMessage(base64Audio, "realtime");
+        this.sendEvent("realtime_input", message);
+      }
+    }, "gemini-live.send")();
+  }
+  /**
+   * Process speech from audio stream (traditional STT interface)
+   */
+  async listen(audioStream, _options) {
+    return this.traced(async () => {
+      this.validateConnectionState();
+      let transcriptionText = "";
+      const onWriting = (data) => {
+        if (data.role === "user") {
+          transcriptionText += data.text;
+          this.log("Received transcription text:", { text: data.text, total: transcriptionText });
+        }
+      };
+      const onError = (error) => {
+        throw new Error(`Transcription failed: ${error.message}`);
+      };
+      const onSession = (data) => {
+        if (data.state === "disconnected") {
+          throw new Error("Session disconnected during transcription");
+        }
+      };
+      this.on("writing", onWriting);
+      this.on("error", onError);
+      this.on("session", onSession);
+      try {
+        const result = await this.audioStreamManager.handleAudioTranscription(
+          audioStream,
+          (base64Audio) => {
+            return new Promise((resolve, reject) => {
+              try {
+                const message = this.audioStreamManager.createAudioMessage(base64Audio, "input");
+                const cleanup = () => {
+                  this.off("turnComplete", onTurnComplete);
+                  this.off("error", onErr);
+                };
+                const onTurnComplete = () => {
+                  cleanup();
+                  resolve(transcriptionText.trim());
+                };
+                const onErr = (e) => {
+                  cleanup();
+                  reject(new Error(e.message));
+                };
+                this.on("turnComplete", onTurnComplete);
+                this.on("error", onErr);
+                this.sendEvent("client_content", message);
+                this.log("Sent audio for transcription");
+              } catch (err) {
+                reject(err);
+              }
+            });
+          },
+          (error) => {
+            this.createAndEmitError("audio_processing_error" /* AUDIO_PROCESSING_ERROR */, "Audio transcription failed", error);
+          }
+        );
+        return result;
+      } finally {
+        this.off("writing", onWriting);
+        this.off("error", onError);
+        this.off("session", onSession);
+      }
+    }, "gemini-live.listen")();
+  }
+  /**
+   * Get available speakers/voices
+   */
+  async getSpeakers() {
+    return this.traced(async () => {
+      return [
+        { voiceId: "Puck", description: "Conversational, friendly" },
+        { voiceId: "Charon", description: "Deep, authoritative" },
+        { voiceId: "Kore", description: "Neutral, professional" },
+        { voiceId: "Fenrir", description: "Warm, approachable" }
+      ];
+    }, "gemini-live.getSpeakers")();
+  }
+  /**
+   * Resume a previous session using a session handle
+   */
+  async resumeSession(handle, context) {
+    if (this.state === "connected") {
+      throw new Error("Cannot resume session while already connected. Disconnect first.");
+    }
+    this.log("Attempting to resume session", { handle });
+    this.sessionHandle = handle;
+    this.isResuming = true;
+    if (context && context.length > 0) {
+      this.contextManager.clearContext();
+      for (const item of context) {
+        this.contextManager.addEntry(item.role, item.content);
+      }
+    }
+    try {
+      await this.connect();
+      this.log("Session resumed successfully", { handle, contextItems: context?.length || 0 });
+    } catch (error) {
+      this.isResuming = false;
+      this.sessionHandle = void 0;
+      throw new Error(`Failed to resume session: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Update session configuration during an active session
+   * Allows dynamic updates to voice, instructions, tools, and other settings
+   *
+   * @param config Partial configuration to update
+   * @throws Error if not connected or update fails
+   *
+   * @example
+   * ```typescript
+   * // Change voice during conversation
+   * await voice.updateSessionConfig({
+   *   speaker: 'Charon'
+   * });
+   *
+   * // Update instructions
+   * await voice.updateSessionConfig({
+   *   instructions: 'You are now a helpful coding assistant'
+   * });
+   *
+   * // Add or update tools
+   * await voice.updateSessionConfig({
+   *   tools: [{ name: 'new_tool', ... }]
+   * });
+   * ```
+   */
+  async updateSessionConfig(config) {
+    this.validateConnectionState();
+    this.validateWebSocketState();
+    return new Promise((resolve, reject) => {
+      if (config.model) {
+        this.log("Warning: Model cannot be changed during an active session. Ignoring model update.");
+      }
+      if (config.vertexAI !== void 0 || config.project !== void 0 || config.location !== void 0) {
+        this.log("Warning: Authentication settings cannot be changed during an active session.");
+      }
+      const updateMessage = {
+        type: "session.update",
+        session: {}
+      };
+      let hasUpdates = false;
+      if (config.speaker) {
+        hasUpdates = true;
+        updateMessage.session.generation_config = {
+          ...updateMessage.session.generation_config,
+          speech_config: {
+            voice_config: {
+              prebuilt_voice_config: {
+                voice_name: config.speaker
+              }
+            }
+          }
+        };
+        this.speaker = config.speaker;
+        this.log("Updating speaker to:", config.speaker);
+      }
+      if (config.instructions !== void 0) {
+        hasUpdates = true;
+        updateMessage.session.system_instruction = {
+          parts: [{ text: config.instructions }]
+        };
+        this.log("Updating instructions");
+      }
+      if (config.tools !== void 0) {
+        hasUpdates = true;
+        if (config.tools.length > 0) {
+          updateMessage.session.tools = config.tools.map((tool) => ({
+            function_declarations: [
+              {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters
+              }
+            ]
+          }));
+        } else {
+          updateMessage.session.tools = [];
+        }
+        this.log("Updating tools:", config.tools.length, "tools");
+      }
+      if (this.tools && Object.keys(this.tools).length > 0) {
+        hasUpdates = true;
+        const allTools = [];
+        for (const [toolName, tool] of Object.entries(this.tools)) {
+          try {
+            let parameters;
+            if ("inputSchema" in tool && tool.inputSchema) {
+              if (typeof tool.inputSchema === "object" && "safeParse" in tool.inputSchema) {
+                parameters = this.convertZodSchemaToJsonSchema(tool.inputSchema);
+              } else {
+                parameters = tool.inputSchema;
+              }
+            } else if ("parameters" in tool && tool.parameters) {
+              parameters = tool.parameters;
+            } else {
+              parameters = { type: "object", properties: {} };
+            }
+            allTools.push({
+              function_declarations: [
+                {
+                  name: toolName,
+                  description: tool.description || `Tool: ${toolName}`,
+                  parameters
+                }
+              ]
+            });
+          } catch (error) {
+            this.log("Failed to process tool for session update", { toolName, error });
+          }
+        }
+        if (allTools.length > 0) {
+          updateMessage.session.tools = allTools;
+          this.log("Updating tools from addTools method:", allTools.length, "tools");
+        }
+      }
+      if (config.sessionConfig) {
+        if (config.sessionConfig.vad) {
+          hasUpdates = true;
+          updateMessage.session.vad = {
+            enabled: config.sessionConfig.vad.enabled ?? true,
+            sensitivity: config.sessionConfig.vad.sensitivity ?? 0.5,
+            silence_duration_ms: config.sessionConfig.vad.silenceDurationMs ?? 1e3
+          };
+          this.log("Updating VAD settings:", config.sessionConfig.vad);
+        }
+        if (config.sessionConfig.interrupts) {
+          hasUpdates = true;
+          updateMessage.session.interrupts = {
+            enabled: config.sessionConfig.interrupts.enabled ?? true,
+            allow_user_interruption: config.sessionConfig.interrupts.allowUserInterruption ?? true
+          };
+          this.log("Updating interrupt settings:", config.sessionConfig.interrupts);
+        }
+        if (config.sessionConfig.contextCompression !== void 0) {
+          hasUpdates = true;
+          updateMessage.session.context_compression = config.sessionConfig.contextCompression;
+          this.log("Updating context compression:", config.sessionConfig.contextCompression);
+          this.contextManager.setCompressionEnabled(config.sessionConfig.contextCompression);
+        }
+      }
+      if (!hasUpdates) {
+        this.log("No valid configuration updates to send");
+        resolve();
+        return;
+      }
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Session configuration update timeout - no response received"));
+      }, 1e4);
+      const onSessionUpdated = (data) => {
+        cleanup();
+        this.log("Session configuration updated successfully", data);
+        resolve();
+      };
+      const onError = (error) => {
+        cleanup();
+        this.log("Session configuration update failed", error);
+        reject(new Error(`Failed to update session configuration: ${error.message || "Unknown error"}`));
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.eventManager.getEventEmitter().removeListener("session.updated", onSessionUpdated);
+        this.eventManager.getEventEmitter().removeListener("error", onError);
+      };
+      this.eventManager.getEventEmitter().once("session.updated", onSessionUpdated);
+      this.eventManager.getEventEmitter().once("error", onError);
+      try {
+        this.sendEvent("session.update", updateMessage);
+        this.log("Sent session configuration update", updateMessage);
+      } catch (error) {
+        cleanup();
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        this.log("Failed to send session configuration update", error);
+        reject(new Error(`Failed to send session configuration update: ${errorMessage}`));
+      }
+    });
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.state;
+  }
+  /**
+   * Check if currently connected
+   */
+  isConnected() {
+    return this.state === "connected";
+  }
+  /**
+   * Get current speaker stream for audio concatenation
+   * This allows external access to the current audio stream being built
+   */
+  getCurrentSpeakerStream() {
+    return this.audioStreamManager.getCurrentSpeakerStream();
+  }
+  /**
+   * Get session handle for resumption
+   */
+  getSessionHandle() {
+    return this.sessionHandle;
+  }
+  /**
+   * Get comprehensive session information
+   */
+  getSessionInfo() {
+    return {
+      id: this.sessionId,
+      handle: this.sessionHandle,
+      startTime: this.sessionStartTime ? new Date(this.sessionStartTime) : void 0,
+      duration: this.sessionStartTime ? Date.now() - this.sessionStartTime : void 0,
+      state: this.state,
+      config: this.options.sessionConfig,
+      contextSize: this.contextManager.getContextSize()
+    };
+  }
+  /**
+   * Get session context history
+   */
+  getContextHistory() {
+    return this.contextManager.getContextHistory();
+  }
+  /**
+   * Add to context history for session continuity
+   */
+  addToContext(role, content) {
+    this.contextManager.addEntry(role, content);
+  }
+  /**
+   * Clear session context
+   */
+  clearContext() {
+    this.contextManager.clearContext();
+    this.log("Session context cleared");
+  }
+  /**
+   * Enable or disable automatic reconnection
+   */
+  setAutoReconnect(enabled) {
+    if (!this.options.sessionConfig) {
+      this.options.sessionConfig = {};
+    }
+    this.options.sessionConfig.enableResumption = enabled;
+    this.log(`Auto-reconnect ${enabled ? "enabled" : "disabled"}`);
+  }
+  /**
+   * Send session resumption message
+   * @private
+   */
+  async sendSessionResumption() {
+    if (!this.sessionHandle) {
+      throw new Error("No session handle available for resumption");
+    }
+    const context = this.contextManager.getContextArray();
+    const resumeMessage = {
+      session_resume: {
+        handle: this.sessionHandle,
+        ...context.length > 0 && {
+          context
+        }
+      }
+    };
+    try {
+      if (this.ws?.readyState !== WebSocket.OPEN) {
+        throw new Error("WebSocket not ready for session resumption");
+      }
+      this.sendEvent("session_resume", resumeMessage);
+      this.log("Session resumption message sent", { handle: this.sessionHandle });
+    } catch (error) {
+      this.log("Failed to send session resumption", error);
+      throw new Error(`Failed to send session resumption: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Start monitoring session duration
+   * @private
+   */
+  startSessionDurationMonitor() {
+    if (!this.options.sessionConfig?.maxDuration) {
+      return;
+    }
+    const durationMs = this.parseDuration(this.options.sessionConfig.maxDuration);
+    if (!durationMs) {
+      this.log("Invalid session duration format", { duration: this.options.sessionConfig.maxDuration });
+      return;
+    }
+    if (this.sessionDurationTimeout) {
+      clearTimeout(this.sessionDurationTimeout);
+    }
+    const warningTime = durationMs - 5 * 60 * 1e3;
+    if (warningTime > 0) {
+      setTimeout(() => {
+        this.emit("sessionExpiring", {
+          expiresIn: 5 * 60 * 1e3,
+          sessionId: this.sessionId
+        });
+      }, warningTime);
+    }
+    this.sessionDurationTimeout = setTimeout(() => {
+      this.log("Session duration limit reached, disconnecting");
+      void this.disconnect();
+    }, durationMs);
+  }
+  /**
+   * Parse duration string to milliseconds
+   * @private
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)([hms])$/);
+    if (!match) return null;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "h":
+        return value * 60 * 60 * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "s":
+        return value * 1e3;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Compress context history to manage memory
+   * @private
+   */
+  compressContext() {
+    this.log("compressContext is deprecated; handled by ContextManager");
+  }
+  /**
+   * Setup WebSocket event listeners for Gemini Live API messages
+   * @private
+   */
+  setupEventListeners() {
+    if (!this.ws) {
+      throw new Error("WebSocket not initialized");
+    }
+    this.ws.on("open", () => {
+      this.log("WebSocket connection opened");
+    });
+    this.ws.on("close", (code, reason) => {
+      this.log("WebSocket connection closed", { code, reason: reason.toString() });
+      this.state = "disconnected";
+      this.emit("session", { state: "disconnected" });
+    });
+    this.ws.on("error", (error) => {
+      this.log("WebSocket error", error);
+      this.state = "disconnected";
+      this.emit("session", { state: "disconnected" });
+      this.emit("error", {
+        message: error.message,
+        code: "websocket_error",
+        details: error
+      });
+    });
+    this.ws.on("message", async (message) => {
+      try {
+        const data = JSON.parse(message.toString());
+        await this.handleGeminiMessage(data);
+      } catch (error) {
+        this.log("Failed to parse WebSocket message", error);
+        this.emit("error", {
+          message: "Failed to parse WebSocket message",
+          code: "parse_error",
+          details: error
+        });
+      }
+    });
+  }
+  /**
+   * Handle different types of messages from Gemini Live API
+   * @private
+   */
+  async handleGeminiMessage(data) {
+    this.log("Received message:", JSON.stringify(data, null, 2));
+    if (data.responseId) {
+      this.setCurrentResponseId(data.responseId);
+      this.log("Set current response ID:", data.responseId);
+    }
+    if (data.setup) {
+      this.log("Processing setup message");
+      this.handleSetupComplete(data);
+    } else if (data.setupComplete) {
+      this.log("Processing setupComplete message");
+      this.handleSetupComplete(data);
+    } else if (data.serverContent) {
+      this.log("Processing server content message");
+      this.handleServerContent(data.serverContent);
+    } else if (data.toolCall) {
+      this.log("Processing tool call message");
+      await this.handleToolCall(data);
+    } else if (data.usageMetadata) {
+      this.log("Processing usage metadata message");
+      this.handleUsageUpdate(data);
+    } else if (data.sessionEnd) {
+      this.log("Processing session end message");
+      this.handleSessionEnd(data);
+    } else if (data.error) {
+      this.log("Processing error message");
+      this.handleError(data.error);
+    } else {
+      const messageData = data;
+      if (messageData.type === "setup" || messageData.type === "session.ready" || messageData.type === "ready") {
+        this.log("Processing alternative setup message with type:", messageData.type);
+        this.handleSetupComplete(data);
+      } else if (messageData.sessionHandle) {
+        this.log("Processing session handle message");
+        this.handleSetupComplete(data);
+      } else if (messageData.session || messageData.ready || messageData.status === "ready" || messageData.status === "setup_complete") {
+        this.log("Processing setup completion message with status:", messageData.status);
+        this.handleSetupComplete(data);
+      } else if (messageData.candidates || messageData.promptFeedback) {
+        this.log("Processing BidiGenerateContent response");
+        this.handleSetupComplete(data);
+      } else if (messageData.contents && Array.isArray(messageData.contents)) {
+        this.log("Processing content response");
+        this.handleServerContent({ modelTurn: { parts: messageData.contents.flatMap((c) => c.parts || []) } });
+        this.handleSetupComplete(data);
+      } else if (messageData.candidates && Array.isArray(messageData.candidates)) {
+        this.log("Processing candidates response");
+        this.handleSetupComplete(data);
+      } else {
+        this.log("Unknown message format - no recognized fields found");
+      }
+    }
+  }
+  /**
+   * Handle setup completion message
+   * @private
+   */
+  handleSetupComplete(data) {
+    this.log("Setup completed");
+    const queue = this.queue.splice(0, this.queue.length);
+    if (queue.length > 0) {
+      this.log("Processing queued messages:", queue.length);
+      for (const queuedMessage of queue) {
+        try {
+          this.connectionManager.send(JSON.stringify(queuedMessage));
+          this.log("Sent queued message:", queuedMessage);
+        } catch (err) {
+          this.log("Failed to send queued message, re-queuing:", err);
+          this.queue.unshift(queuedMessage);
+          break;
+        }
+      }
+    }
+    this.eventManager.getEventEmitter().emit("setupComplete", data);
+  }
+  /**
+   * Handle session update confirmation
+   * @private
+   */
+  handleSessionUpdated(data) {
+    this.log("Session updated", data);
+    this.eventManager.getEventEmitter().emit("session.updated", data);
+    this.emit("session", {
+      state: "updated",
+      config: data
+    });
+  }
+  /**
+   * Handle server content (text/audio responses)
+   * @private
+   */
+  handleServerContent(data) {
+    if (!data) {
+      return;
+    }
+    let assistantResponse = "";
+    if (data.modelTurn?.parts) {
+      for (const part of data.modelTurn.parts) {
+        if (part.text) {
+          assistantResponse += part.text;
+          this.emit("writing", {
+            text: part.text,
+            role: "assistant"
+          });
+        }
+        if (part.inlineData?.mimeType?.includes("audio") && typeof part.inlineData.data === "string") {
+          try {
+            const audioData = part.inlineData.data;
+            const int16Array = this.audioStreamManager.base64ToInt16Array(audioData);
+            const responseId = this.getCurrentResponseId() || randomUUID();
+            let speakerStream = this.audioStreamManager.getSpeakerStream(responseId);
+            if (!speakerStream) {
+              this.audioStreamManager.cleanupStaleStreams();
+              this.audioStreamManager.enforceStreamLimits();
+              speakerStream = this.audioStreamManager.createSpeakerStream(responseId);
+              speakerStream.on("error", (streamError) => {
+                this.log(`Speaker stream error for ${responseId}:`, streamError);
+                this.audioStreamManager.removeSpeakerStream(responseId);
+                this.emit("error", {
+                  message: "Speaker stream error",
+                  code: "speaker_stream_error",
+                  details: { responseId, error: streamError }
+                });
+              });
+              speakerStream.on("end", () => {
+                this.log(`Speaker stream ended for response: ${responseId}`);
+                this.audioStreamManager.removeSpeakerStream(responseId);
+              });
+              speakerStream.on("close", () => {
+                this.log(`Speaker stream closed for response: ${responseId}`);
+                this.audioStreamManager.removeSpeakerStream(responseId);
+              });
+              this.log("Created new speaker stream for response:", responseId);
+              this.emit("speaker", speakerStream);
+            }
+            const audioBuffer = Buffer.from(int16Array.buffer, int16Array.byteOffset, int16Array.byteLength);
+            speakerStream.write(audioBuffer);
+            this.log("Wrote audio chunk to stream:", {
+              responseId,
+              chunkSize: audioBuffer.length,
+              totalStreams: this.audioStreamManager.getActiveStreamCount()
+            });
+            this.emit("speaking", {
+              audio: audioData,
+              // Base64 string
+              audioData: int16Array,
+              sampleRate: this.audioConfig.outputSampleRate
+              // Gemini Live outputs at 24kHz
+            });
+          } catch (error) {
+            this.log("Error processing audio data:", error);
+            this.emit("error", {
+              message: "Failed to process audio data",
+              code: "audio_processing_error",
+              details: error
+            });
+          }
+        }
+      }
+    }
+    if (assistantResponse.trim()) {
+      this.addToContext("assistant", assistantResponse);
+    }
+    if (data.turnComplete) {
+      this.log("Turn completed");
+      this.audioStreamManager.cleanupSpeakerStreams();
+      this.emit("turnComplete", {
+        timestamp: Date.now()
+      });
+    }
+  }
+  /**
+   * Handle tool call requests from the model
+   * @private
+   */
+  async handleToolCall(data) {
+    if (!data.toolCall) {
+      return;
+    }
+    const toolName = data.toolCall.name || "";
+    const toolArgs = data.toolCall.args || {};
+    const toolId = data.toolCall.id || randomUUID();
+    this.log("Processing tool call", { toolName, toolArgs, toolId });
+    this.emit("toolCall", {
+      name: toolName,
+      args: toolArgs,
+      id: toolId
+    });
+    const tool = this.tools?.[toolName];
+    if (!tool) {
+      this.log("Tool not found", { toolName });
+      this.createAndEmitError("tool_not_found" /* TOOL_NOT_FOUND */, `Tool "${toolName}" not found`, {
+        toolName,
+        availableTools: Object.keys(this.tools || {})
+      });
+      return;
+    }
+    try {
+      let result;
+      if (tool.execute) {
+        this.log("Executing tool", { toolName, toolArgs });
+        result = await tool.execute(
+          { context: toolArgs, runtimeContext: this.runtimeContext },
+          {
+            toolCallId: toolId,
+            messages: []
+          }
+        );
+        this.log("Tool executed successfully", { toolName, result });
+      } else {
+        this.log("Tool has no execute function", { toolName });
+        result = { error: "Tool has no execute function" };
+      }
+      const toolResultMessage = {
+        tool_result: {
+          tool_call_id: toolId,
+          result
+        }
+      };
+      this.sendEvent("tool_result", toolResultMessage);
+      this.log("Tool result sent", { toolName, toolId, result });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.log("Tool execution failed", { toolName, error: errorMessage });
+      const errorResultMessage = {
+        tool_result: {
+          tool_call_id: toolId,
+          result: { error: errorMessage }
+        }
+      };
+      this.sendEvent("tool_result", errorResultMessage);
+      this.createAndEmitError("tool_execution_error" /* TOOL_EXECUTION_ERROR */, `Tool execution failed: ${errorMessage}`, {
+        toolName,
+        toolArgs,
+        error
+      });
+    }
+  }
+  /**
+   * Handle token usage information
+   * @private
+   */
+  handleUsageUpdate(data) {
+    if (data.usageMetadata) {
+      this.emit("usage", {
+        inputTokens: data.usageMetadata.promptTokenCount || 0,
+        outputTokens: data.usageMetadata.responseTokenCount || 0,
+        totalTokens: data.usageMetadata.totalTokenCount || 0,
+        modality: this.determineModality(data)
+      });
+    }
+  }
+  /**
+   * Handle session end
+   * @private
+   */
+  handleSessionEnd(data) {
+    this.log("Session ended", data.sessionEnd?.reason);
+    this.state = "disconnected";
+    this.emit("session", { state: "disconnected" });
+  }
+  /**
+   * Handle errors
+   * @private
+   */
+  handleError(error) {
+    if (!error) {
+      this.log("Received error from Gemini Live API (no error details)");
+      return;
+    }
+    this.log("Received error from Gemini Live API", error);
+    this.emit("error", {
+      message: error.message || "Unknown error",
+      code: error.code || "unknown_error",
+      details: error.details
+    });
+  }
+  /**
+   * Determine the modality from message data
+   * @private
+   */
+  determineModality(data) {
+    if (data.serverContent?.modelTurn?.parts?.some((part) => part.inlineData?.mimeType?.includes("audio"))) {
+      return "audio";
+    }
+    if (data.serverContent?.modelTurn?.parts?.some((part) => part.inlineData?.mimeType?.includes("video"))) {
+      return "video";
+    }
+    return "text";
+  }
+  /**
+   * Send initial configuration to Gemini Live API
+   * @private
+   */
+  sendInitialConfig() {
+    if (!this.ws || !this.connectionManager.isConnected()) {
+      throw new Error("WebSocket not connected");
+    }
+    const setupMessage = {
+      setup: {
+        model: `models/${this.options.model}`
+      }
+    };
+    if (this.options.instructions) {
+      setupMessage.setup.systemInstruction = {
+        parts: [{ text: this.options.instructions }]
+      };
+    }
+    const allTools = [];
+    if (this.options.tools && this.options.tools.length > 0) {
+      for (const tool of this.options.tools) {
+        allTools.push({
+          functionDeclarations: [
+            {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.parameters
+            }
+          ]
+        });
+      }
+    }
+    if (this.tools && Object.keys(this.tools).length > 0) {
+      for (const [toolName, tool] of Object.entries(this.tools)) {
+        try {
+          let parameters;
+          if ("inputSchema" in tool && tool.inputSchema) {
+            if (typeof tool.inputSchema === "object" && "safeParse" in tool.inputSchema) {
+              parameters = this.convertZodSchemaToJsonSchema(tool.inputSchema);
+            } else {
+              parameters = tool.inputSchema;
+            }
+          } else if ("parameters" in tool && tool.parameters) {
+            parameters = tool.parameters;
+          } else {
+            parameters = { type: "object", properties: {} };
+          }
+          allTools.push({
+            functionDeclarations: [
+              {
+                name: toolName,
+                description: tool.description || `Tool: ${toolName}`,
+                parameters
+              }
+            ]
+          });
+        } catch (error) {
+          this.log("Failed to process tool", { toolName, error });
+        }
+      }
+    }
+    if (allTools.length > 0) {
+      setupMessage.setup.tools = allTools;
+      this.log("Including tools in setup message", { toolCount: allTools.length });
+    }
+    this.log("Sending Live API setup message:", setupMessage);
+    try {
+      this.sendEvent("setup", setupMessage);
+    } catch (error) {
+      this.log("Failed to send Live API setup message:", error);
+      throw new Error(
+        `Failed to send Live API setup message: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Wait for Gemini Live session to be created and ready
+   * @private
+   */
+  waitForSessionCreated() {
+    return new Promise((resolve, reject) => {
+      let isResolved = false;
+      const onSetupComplete = () => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          resolve();
+        }
+      };
+      const onError = (errorData) => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error(`Session creation failed: ${errorData.message || "Unknown error"}`));
+        }
+      };
+      const onSessionEnd = () => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error("Session ended before setup completed"));
+        }
+      };
+      const cleanup = () => {
+        this.eventManager.getEventEmitter().removeListener("setupComplete", onSetupComplete);
+        this.eventManager.getEventEmitter().removeListener("error", onError);
+        this.eventManager.getEventEmitter().removeListener("sessionEnd", onSessionEnd);
+      };
+      this.eventManager.getEventEmitter().once("setupComplete", onSetupComplete);
+      this.eventManager.getEventEmitter().once("error", onError);
+      this.eventManager.getEventEmitter().once("sessionEnd", onSessionEnd);
+      setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error("Session creation timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Get OAuth access token for Vertex AI authentication
+   * Implements token caching and automatic refresh
+   * @private
+   */
+  async getAccessToken() {
+    if (!this.options.vertexAI) {
+      throw new Error("getAccessToken should only be called for Vertex AI mode");
+    }
+    return this.authManager.getAccessToken();
+  }
+  /**
+   * Get the current response ID from the server message
+   * This is needed to associate audio chunks with their respective responses.
+   * @private
+   */
+  getCurrentResponseId() {
+    return this.audioStreamManager.getCurrentResponseId();
+  }
+  /**
+   * Set the current response ID for the next audio chunk.
+   * This is used to track the response ID for the current turn.
+   * @private
+   */
+  setCurrentResponseId(responseId) {
+    this.audioStreamManager.setCurrentResponseId(responseId);
+  }
+  /**
+   * Send an event to the Gemini Live API with queueing support
+   * @private
+   */
+  sendEvent(type, data) {
+    let message;
+    if (type === "setup" && data.setup) {
+      message = data;
+    } else if (type === "client_content" && data.client_content) {
+      message = data;
+    } else if (type === "realtime_input" && data.realtime_input) {
+      message = data;
+    } else if (type === "session.update" && data.session) {
+      message = data;
+    } else {
+      message = { type, ...data };
+    }
+    if (!this.ws || !this.connectionManager.isConnected()) {
+      this.queue.push(message);
+      this.log("Queued message:", { type, data });
+    } else {
+      this.connectionManager.send(JSON.stringify(message));
+      this.log("Sent message:", { type, data });
+    }
+  }
+  /**
+   * Equip the voice provider with tools
+   * @param tools Object containing tool definitions that can be called by the voice model
+   *
+   * @example
+   * ```typescript
+   * const weatherTool = createTool({
+   *   id: "getWeather",
+   *   description: "Get the current weather for a location",
+   *   inputSchema: z.object({
+   *     location: z.string().describe("The city and state, e.g. San Francisco, CA"),
+   *   }),
+   *   execute: async ({ context }) => {
+   *     // Fetch weather data from an API
+   *     const response = await fetch(
+   *       `https://api.weather.com?location=${encodeURIComponent(context.location)}`,
+   *     );
+   *     const data = await response.json();
+   *     return {
+   *       message: `The current temperature in ${context.location} is ${data.temperature}°F with ${data.conditions}.`,
+   *     };
+   *   },
+   * });
+   *
+   * voice.addTools({
+   *   getWeather: weatherTool,
+   * });
+   * ```
+   */
+  addTools(tools) {
+    this.tools = tools;
+    this.log("Tools added to Gemini Live Voice", { toolCount: Object.keys(tools || {}).length });
+  }
+  /**
+   * Get the current tools configured for this voice instance
+   * @returns Object containing the current tools
+   */
+  getTools() {
+    return this.tools;
+  }
+  log(message, ...args) {
+    if (this.debug) {
+      console.log(`[GeminiLiveVoice] ${message}`, ...args);
+    }
+  }
+  /**
+   * Convert Zod schema to JSON Schema for tool parameters
+   * @private
+   */
+  convertZodSchemaToJsonSchema(schema) {
+    try {
+      if (typeof schema.toJSON === "function") {
+        return schema.toJSON();
+      }
+      if (schema._def) {
+        return this.convertZodDefToJsonSchema(schema._def);
+      }
+      if (typeof schema === "object" && !schema.safeParse) {
+        return schema;
+      }
+      return {
+        type: "object",
+        properties: {},
+        description: schema.description || ""
+      };
+    } catch (error) {
+      this.log("Failed to convert Zod schema to JSON schema", { error, schema });
+      return {
+        type: "object",
+        properties: {},
+        description: "Schema conversion failed"
+      };
+    }
+  }
+  /**
+   * Convert Zod definition to JSON Schema
+   * @private
+   */
+  convertZodDefToJsonSchema(def) {
+    switch (def.typeName) {
+      case "ZodString":
+        return {
+          type: "string",
+          description: def.description || ""
+        };
+      case "ZodNumber":
+        return {
+          type: "number",
+          description: def.description || ""
+        };
+      case "ZodBoolean":
+        return {
+          type: "boolean",
+          description: def.description || ""
+        };
+      case "ZodArray":
+        return {
+          type: "array",
+          items: this.convertZodDefToJsonSchema(def.type._def),
+          description: def.description || ""
+        };
+      case "ZodObject":
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(def.shape())) {
+          properties[key] = this.convertZodDefToJsonSchema(value._def);
+          if (value._def.typeName === "ZodOptional") ; else {
+            required.push(key);
+          }
+        }
+        return {
+          type: "object",
+          properties,
+          required: required.length > 0 ? required : void 0,
+          description: def.description || ""
+        };
+      case "ZodOptional":
+        return this.convertZodDefToJsonSchema(def.innerType._def);
+      case "ZodEnum":
+        return {
+          type: "string",
+          enum: def.values,
+          description: def.description || ""
+        };
+      default:
+        return {
+          type: "object",
+          properties: {},
+          description: def.description || ""
+        };
+    }
+  }
+  /**
+   * Close the connection (alias for disconnect)
+   */
+  close() {
+    void this.disconnect();
+  }
+  /**
+   * Trigger voice provider to respond
+   */
+  async answer(_options) {
+    this.validateConnectionState();
+    this.sendEvent("response.create", {});
+  }
+  /**
+   * Equip the voice provider with instructions
+   * @param instructions Instructions to add
+   */
+  addInstructions(instructions) {
+    if (instructions) {
+      this.options.instructions = instructions;
+      this.log("Instructions added:", instructions);
+    }
+  }
+};
+
+export { GeminiLiveVoice };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map