@drawdream/livespeech 0.1.0

package/dist/index.mjs

@@ -0,0 +1,938 @@
+// src/types/regions.ts
+var Region = {
+  /** Asia Pacific (Seoul) */
+  AP_NORTHEAST_2: "ap-northeast-2",
+  /** US West (Oregon) - Coming soon */
+  US_WEST_2: "us-west-2"
+};
+var REGION_ENDPOINTS = {
+  "ap-northeast-2": "wss://talk.drawdream.co.kr",
+  "us-west-2": "wss://talk..drawdream.ca"
+  // Coming soon
+};
+function getEndpointForRegion(region) {
+  const endpoint = REGION_ENDPOINTS[region];
+  if (!endpoint) {
+    throw new Error(`Unknown region: ${region}. Available regions: ${Object.keys(REGION_ENDPOINTS).join(", ")}`);
+  }
+  return endpoint;
+}
+function isValidRegion(value) {
+  return value in REGION_ENDPOINTS;
+}
+
+// src/types/messages.ts
+function isServerMessage(data) {
+  return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string";
+}
+function parseServerMessage(json) {
+  try {
+    const data = JSON.parse(json);
+    if (isServerMessage(data)) {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function serializeClientMessage(message) {
+  return JSON.stringify(message);
+}
+
+// src/utils/logger.ts
+function createLogger(prefix, enabled) {
+  const formatMessage = (level, message) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `[${timestamp}] [${prefix}] [${level.toUpperCase()}] ${message}`;
+  };
+  const noop = () => {
+  };
+  if (!enabled) {
+    return {
+      debug: noop,
+      info: noop,
+      warn: noop,
+      error: noop
+    };
+  }
+  return {
+    debug(message, ...args) {
+      console.debug(formatMessage("debug", message), ...args);
+    },
+    info(message, ...args) {
+      console.info(formatMessage("info", message), ...args);
+    },
+    warn(message, ...args) {
+      console.warn(formatMessage("warn", message), ...args);
+    },
+    error(message, ...args) {
+      console.error(formatMessage("error", message), ...args);
+    }
+  };
+}
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxAttempts: 5,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2,
+  jitter: true,
+  isRetryable: () => true
+};
+function calculateDelay(attempt, baseDelay, maxDelay, backoffMultiplier, jitter) {
+  const exponentialDelay = baseDelay * Math.pow(backoffMultiplier, attempt - 1);
+  const cappedDelay = Math.min(exponentialDelay, maxDelay);
+  if (jitter) {
+    const jitterRange = cappedDelay * 0.25;
+    const jitterValue = Math.random() * jitterRange * 2 - jitterRange;
+    return Math.max(0, Math.round(cappedDelay + jitterValue));
+  }
+  return Math.round(cappedDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var RetryController = class {
+  attempt = 0;
+  options;
+  aborted = false;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Get current attempt number
+   */
+  get currentAttempt() {
+    return this.attempt;
+  }
+  /**
+   * Check if more retries are available
+   */
+  get canRetry() {
+    return !this.aborted && this.attempt < this.options.maxAttempts;
+  }
+  /**
+   * Get delay for next retry attempt
+   */
+  getNextDelay() {
+    return calculateDelay(
+      this.attempt + 1,
+      this.options.baseDelay,
+      this.options.maxDelay,
+      this.options.backoffMultiplier,
+      this.options.jitter
+    );
+  }
+  /**
+   * Record a retry attempt
+   * @returns The delay to wait before retrying, or null if no more retries
+   */
+  recordAttempt(error) {
+    if (!this.canRetry) {
+      return null;
+    }
+    if (error && !this.options.isRetryable(error)) {
+      return null;
+    }
+    this.attempt++;
+    const delay = this.getNextDelay();
+    if (this.options.onRetry && error) {
+      this.options.onRetry(this.attempt, delay, error);
+    }
+    return delay;
+  }
+  /**
+   * Reset the controller
+   */
+  reset() {
+    this.attempt = 0;
+    this.aborted = false;
+  }
+  /**
+   * Abort any further retries
+   */
+  abort() {
+    this.aborted = true;
+  }
+};
+
+// src/websocket/connection.ts
+var WebSocketConnection = class {
+  ws = null;
+  state = "disconnected";
+  connectionId = null;
+  config;
+  logger;
+  events;
+  retryController;
+  pingInterval = null;
+  constructor(config, events = {}) {
+    this.config = config;
+    this.events = events;
+    this.logger = createLogger("WebSocket", config.debug);
+    this.retryController = new RetryController({
+      maxAttempts: config.maxReconnectAttempts,
+      baseDelay: config.reconnectDelay
+    });
+  }
+  /**
+   * Get current connection state
+   */
+  get currentState() {
+    return this.state;
+  }
+  /**
+   * Get connection ID
+   */
+  get id() {
+    return this.connectionId;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Connect to WebSocket server
+   */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      this.logger.warn("Already connected or connecting");
+      return;
+    }
+    this.state = "connecting";
+    this.retryController.reset();
+    await this.attemptConnection();
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.retryController.abort();
+    this.stopPingInterval();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.connectionId = null;
+    this.logger.info("Disconnected");
+  }
+  /**
+   * Send a message
+   */
+  send(message) {
+    if (!this.isConnected) {
+      throw new Error("Not connected");
+    }
+    const data = serializeClientMessage(message);
+    this.logger.debug("Sending message:", message.action);
+    this.ws.send(data);
+  }
+  /**
+   * Attempt to establish connection
+   */
+  async attemptConnection() {
+    return new Promise((resolve, reject) => {
+      try {
+        const url = new URL(this.config.endpoint);
+        url.searchParams.set("apiKey", this.config.apiKey);
+        this.logger.info("Connecting to", url.origin);
+        this.ws = new WebSocket(url.toString());
+        const timeoutId = setTimeout(() => {
+          if (this.state === "connecting") {
+            this.ws?.close();
+            reject(new Error("Connection timeout"));
+          }
+        }, this.config.connectionTimeout);
+        this.ws.onopen = () => {
+          clearTimeout(timeoutId);
+          this.logger.info("Connected");
+          this.state = "connected";
+          this.connectionId = this.generateConnectionId();
+          this.retryController.reset();
+          this.startPingInterval();
+          this.events.onOpen?.(this.connectionId);
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          clearTimeout(timeoutId);
+          this.handleClose(event.code, event.reason);
+          if (this.state === "connecting") {
+            reject(new Error(`Connection closed: ${event.reason || "Unknown reason"}`));
+          }
+        };
+        this.ws.onerror = (_event) => {
+          clearTimeout(timeoutId);
+          const error = new Error("WebSocket error");
+          this.logger.error("Connection error");
+          this.events.onError?.(error);
+          if (this.state === "connecting") {
+            reject(error);
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Generate a client-side connection ID
+   */
+  generateConnectionId() {
+    return `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(data, onFirstConnect) {
+    const message = parseServerMessage(data);
+    if (!message) {
+      this.logger.warn("Invalid message received:", data);
+      return;
+    }
+    this.logger.debug("Received message:", message.type);
+    if (message.type === "connected") {
+      this.connectionId = message.connectionId;
+      this.state = "connected";
+      this.retryController.reset();
+      this.startPingInterval();
+      this.events.onOpen?.(message.connectionId);
+      onFirstConnect?.();
+      return;
+    }
+    if (message.type === "pong") {
+      this.logger.debug("Pong received");
+      return;
+    }
+    this.events.onMessage?.(message);
+  }
+  /**
+   * Handle connection close
+   */
+  handleClose(code, reason) {
+    this.logger.info("Connection closed:", code, reason);
+    this.stopPingInterval();
+    const wasConnected = this.state === "connected";
+    this.ws = null;
+    if (wasConnected && this.config.autoReconnect && code !== 1e3) {
+      this.handleReconnection();
+    } else {
+      this.state = "disconnected";
+      this.connectionId = null;
+      this.events.onClose?.(code, reason);
+    }
+  }
+  /**
+   * Handle reconnection logic
+   */
+  async handleReconnection() {
+    const delay = this.retryController.recordAttempt();
+    if (delay === null) {
+      this.logger.error("Max reconnection attempts reached");
+      this.state = "disconnected";
+      this.connectionId = null;
+      this.events.onClose?.(1006, "Max reconnection attempts reached");
+      return;
+    }
+    this.state = "reconnecting";
+    const attempt = this.retryController.currentAttempt;
+    const maxAttempts = this.config.maxReconnectAttempts;
+    this.logger.info(`Reconnecting in ${delay}ms (attempt ${attempt}/${maxAttempts})`);
+    this.events.onReconnecting?.(attempt, maxAttempts, delay);
+    await sleep(delay);
+    if (this.state !== "reconnecting") {
+      return;
+    }
+    try {
+      await this.attemptConnection();
+    } catch (error) {
+      this.logger.error("Reconnection failed:", error);
+      this.handleReconnection();
+    }
+  }
+  /**
+   * Start ping interval for keep-alive
+   */
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.isConnected) {
+        this.send({ action: "ping" });
+      }
+    }, 3e4);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+};
+
+// src/audio/encoder.ts
+var DEFAULT_OPTIONS2 = {
+  format: "pcm16",
+  sampleRate: 16e3,
+  channels: 1,
+  bitDepth: 16
+};
+function encodeAudioToBase64(data) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(data).toString("base64");
+  }
+  let binary = "";
+  const len = data.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return typeof btoa !== "undefined" ? btoa(binary) : binary;
+}
+function decodeBase64ToAudio(base64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = typeof atob !== "undefined" ? atob(base64) : base64;
+  const len = binary.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function float32ToInt16(float32Array) {
+  const int16Array = new Int16Array(float32Array.length);
+  for (let i = 0; i < float32Array.length; i++) {
+    const sample = float32Array[i];
+    const clamped = Math.max(-1, Math.min(1, sample));
+    int16Array[i] = clamped < 0 ? clamped * 32768 : clamped * 32767;
+  }
+  return int16Array;
+}
+function int16ToFloat32(int16Array) {
+  const float32Array = new Float32Array(int16Array.length);
+  for (let i = 0; i < int16Array.length; i++) {
+    const sample = int16Array[i];
+    float32Array[i] = sample / (sample < 0 ? 32768 : 32767);
+  }
+  return float32Array;
+}
+function int16ToUint8(int16Array) {
+  const uint8Array = new Uint8Array(int16Array.length * 2);
+  const view = new DataView(uint8Array.buffer);
+  for (let i = 0; i < int16Array.length; i++) {
+    view.setInt16(i * 2, int16Array[i], true);
+  }
+  return uint8Array;
+}
+function uint8ToInt16(uint8Array) {
+  const int16Array = new Int16Array(uint8Array.length / 2);
+  const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+  for (let i = 0; i < int16Array.length; i++) {
+    int16Array[i] = view.getInt16(i * 2, true);
+  }
+  return int16Array;
+}
+function createWavHeader(dataLength, sampleRate, channels, bitDepth) {
+  const header = new ArrayBuffer(44);
+  const view = new DataView(header);
+  const byteRate = sampleRate * channels * bitDepth / 8;
+  const blockAlign = channels * bitDepth / 8;
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataLength, true);
+  writeString(view, 8, "WAVE");
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitDepth, true);
+  writeString(view, 36, "data");
+  view.setUint32(40, dataLength, true);
+  return new Uint8Array(header);
+}
+function writeString(view, offset, str) {
+  for (let i = 0; i < str.length; i++) {
+    view.setUint8(offset + i, str.charCodeAt(i));
+  }
+}
+function wrapPcmInWav(pcmData, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const header = createWavHeader(pcmData.length, opts.sampleRate, opts.channels, opts.bitDepth);
+  const wav = new Uint8Array(header.length + pcmData.length);
+  wav.set(header);
+  wav.set(pcmData, header.length);
+  return wav;
+}
+function extractPcmFromWav(wavData) {
+  const view = new DataView(wavData.buffer, wavData.byteOffset, wavData.byteLength);
+  const riff = String.fromCharCode(view.getUint8(0), view.getUint8(1), view.getUint8(2), view.getUint8(3));
+  if (riff !== "RIFF") {
+    throw new Error("Invalid WAV file: Missing RIFF header");
+  }
+  const wave = String.fromCharCode(view.getUint8(8), view.getUint8(9), view.getUint8(10), view.getUint8(11));
+  if (wave !== "WAVE") {
+    throw new Error("Invalid WAV file: Missing WAVE format");
+  }
+  const channels = view.getUint16(22, true);
+  const sampleRate = view.getUint32(24, true);
+  const bitDepth = view.getUint16(34, true);
+  let dataOffset = 44;
+  let dataLength = view.getUint32(40, true);
+  if (dataLength === 0 || dataOffset + dataLength > wavData.length) {
+    for (let i = 36; i < wavData.length - 8; i++) {
+      const chunk = String.fromCharCode(
+        view.getUint8(i),
+        view.getUint8(i + 1),
+        view.getUint8(i + 2),
+        view.getUint8(i + 3)
+      );
+      if (chunk === "data") {
+        dataLength = view.getUint32(i + 4, true);
+        dataOffset = i + 8;
+        break;
+      }
+    }
+  }
+  const pcmData = wavData.slice(dataOffset, dataOffset + dataLength);
+  return {
+    pcmData,
+    sampleRate,
+    channels,
+    bitDepth
+  };
+}
+var AudioEncoder = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS2, ...options };
+  }
+  /**
+   * Get current options
+   */
+  get format() {
+    return this.options.format;
+  }
+  get sampleRate() {
+    return this.options.sampleRate;
+  }
+  /**
+   * Encode audio data for transmission
+   */
+  encode(data) {
+    return encodeAudioToBase64(data);
+  }
+  /**
+   * Decode received audio data
+   */
+  decode(base64) {
+    return decodeBase64ToAudio(base64);
+  }
+  /**
+   * Convert Float32 samples to transmission-ready format
+   */
+  fromFloat32(samples) {
+    const int16 = float32ToInt16(samples);
+    return int16ToUint8(int16);
+  }
+  /**
+   * Convert received data to Float32 samples
+   */
+  toFloat32(data) {
+    const int16 = uint8ToInt16(data);
+    return int16ToFloat32(int16);
+  }
+  /**
+   * Wrap data in WAV format if needed
+   */
+  wrapWav(data) {
+    if (this.options.format === "wav") {
+      return wrapPcmInWav(data, this.options);
+    }
+    return data;
+  }
+};
+
+// src/client.ts
+var CONFIG_DEFAULTS = {
+  connectionTimeout: 3e4,
+  autoReconnect: true,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1e3,
+  debug: false
+};
+var SESSION_DEFAULTS = {
+  voiceId: "en-US-Standard-A",
+  languageCode: "en-US",
+  inputFormat: "pcm16",
+  outputFormat: "pcm16",
+  sampleRate: 16e3
+};
+var LiveSpeechClient = class {
+  config;
+  connection;
+  audioEncoder;
+  logger;
+  sessionId = null;
+  sessionConfig = null;
+  // Event listeners using a simple map
+  eventListeners = /* @__PURE__ */ new Map();
+  // Simplified handlers
+  transcriptHandler = null;
+  responseHandler = null;
+  audioHandler = null;
+  errorHandler = null;
+  constructor(config) {
+    if (!config.region) {
+      throw new Error("region is required");
+    }
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    const endpoint = getEndpointForRegion(config.region);
+    this.config = {
+      endpoint,
+      apiKey: config.apiKey,
+      connectionTimeout: config.connectionTimeout ?? CONFIG_DEFAULTS.connectionTimeout,
+      autoReconnect: config.autoReconnect ?? CONFIG_DEFAULTS.autoReconnect,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? CONFIG_DEFAULTS.maxReconnectAttempts,
+      reconnectDelay: config.reconnectDelay ?? CONFIG_DEFAULTS.reconnectDelay,
+      debug: config.debug ?? CONFIG_DEFAULTS.debug
+    };
+    this.logger = createLogger("LiveSpeech", this.config.debug);
+    this.audioEncoder = new AudioEncoder();
+    this.connection = new WebSocketConnection(this.config, {
+      onOpen: (connectionId) => this.handleConnected(connectionId),
+      onClose: (code, reason) => this.handleDisconnected(code, reason),
+      onError: (error) => this.handleError("connection_failed", error.message),
+      onMessage: (message) => this.handleMessage(message),
+      onReconnecting: (attempt, maxAttempts, delay) => this.handleReconnecting(attempt, maxAttempts, delay)
+    });
+  }
+  // ==================== Public API ====================
+  /**
+   * Get current connection state
+   */
+  get connectionState() {
+    return this.connection.currentState;
+  }
+  /**
+   * Get connection ID
+   */
+  get connectionId() {
+    return this.connection.id;
+  }
+  /**
+   * Get current session ID
+   */
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.connection.isConnected;
+  }
+  /**
+   * Check if session is active
+   */
+  get hasActiveSession() {
+    return this.sessionId !== null;
+  }
+  /**
+   * Connect to the server
+   */
+  async connect() {
+    this.logger.info("Connecting...");
+    await this.connection.connect();
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    this.logger.info("Disconnecting...");
+    this.sessionId = null;
+    this.sessionConfig = null;
+    this.connection.disconnect();
+  }
+  /**
+   * Start a new session
+   */
+  async startSession(config) {
+    if (!this.isConnected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    if (this.sessionId) {
+      throw new Error("Session already active. Call endSession() first.");
+    }
+    const resolvedConfig = {
+      prePrompt: config.prePrompt,
+      voiceId: config.voiceId ?? SESSION_DEFAULTS.voiceId,
+      languageCode: config.languageCode ?? SESSION_DEFAULTS.languageCode,
+      inputFormat: config.inputFormat ?? SESSION_DEFAULTS.inputFormat,
+      outputFormat: config.outputFormat ?? SESSION_DEFAULTS.outputFormat,
+      sampleRate: config.sampleRate ?? SESSION_DEFAULTS.sampleRate,
+      metadata: config.metadata ?? {}
+    };
+    this.sessionConfig = resolvedConfig;
+    this.logger.info("Starting session...");
+    return new Promise((resolve, reject) => {
+      const onSessionStarted = (event) => {
+        this.off("sessionStarted", onSessionStarted);
+        this.off("error", onError);
+        resolve(event.sessionId);
+      };
+      const onError = (event) => {
+        if (event.code === "session_error") {
+          this.off("sessionStarted", onSessionStarted);
+          this.off("error", onError);
+          reject(new Error(event.message));
+        }
+      };
+      this.on("sessionStarted", onSessionStarted);
+      this.on("error", onError);
+      this.connection.send({
+        action: "startSession",
+        prePrompt: resolvedConfig.prePrompt,
+        voiceId: resolvedConfig.voiceId,
+        languageCode: resolvedConfig.languageCode,
+        inputFormat: resolvedConfig.inputFormat,
+        outputFormat: resolvedConfig.outputFormat,
+        sampleRate: resolvedConfig.sampleRate,
+        metadata: resolvedConfig.metadata
+      });
+    });
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (!this.sessionId) {
+      this.logger.warn("No active session to end");
+      return;
+    }
+    this.logger.info("Ending session...");
+    return new Promise((resolve) => {
+      const onSessionEnded = () => {
+        this.off("sessionEnded", onSessionEnded);
+        resolve();
+      };
+      this.on("sessionEnded", onSessionEnded);
+      this.connection.send({ action: "endSession" });
+    });
+  }
+  /**
+   * Send audio data
+   */
+  sendAudio(data, options) {
+    if (!this.isConnected) {
+      throw new Error("Not connected");
+    }
+    if (!this.sessionId) {
+      throw new Error("No active session. Call startSession() first.");
+    }
+    const base64Data = this.audioEncoder.encode(data);
+    const format = options?.format ?? this.sessionConfig?.inputFormat ?? SESSION_DEFAULTS.inputFormat;
+    const sampleRate = this.sessionConfig?.sampleRate ?? SESSION_DEFAULTS.sampleRate;
+    const audioMessage = {
+      action: "audio",
+      data: base64Data,
+      format,
+      sampleRate
+    };
+    if (options?.isFinal !== void 0) {
+      audioMessage.isFinal = options.isFinal;
+    }
+    this.connection.send(audioMessage);
+  }
+  // ==================== Event System ====================
+  /**
+   * Add event listener
+   */
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  /**
+   * Set transcript handler (simplified)
+   */
+  setTranscriptHandler(handler) {
+    this.transcriptHandler = handler;
+  }
+  /**
+   * Set response handler (simplified)
+   */
+  setResponseHandler(handler) {
+    this.responseHandler = handler;
+  }
+  /**
+   * Set audio handler (simplified)
+   */
+  setAudioHandler(handler) {
+    this.audioHandler = handler;
+  }
+  /**
+   * Set error handler (simplified)
+   */
+  setErrorHandler(handler) {
+    this.errorHandler = handler;
+  }
+  // ==================== Private Methods ====================
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((listener) => {
+        try {
+          listener(data);
+        } catch (error) {
+          this.logger.error(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+  handleConnected(connectionId) {
+    const event = {
+      type: "connected",
+      connectionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("connected", event);
+  }
+  handleDisconnected(code, _reason) {
+    this.sessionId = null;
+    this.sessionConfig = null;
+    const event = {
+      type: "disconnected",
+      reason: code === 1e3 ? "normal" : "error",
+      code,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("disconnected", event);
+  }
+  handleReconnecting(attempt, maxAttempts, delay) {
+    const event = {
+      type: "reconnecting",
+      attempt,
+      maxAttempts,
+      delay,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("reconnecting", event);
+  }
+  handleError(code, message, details) {
+    const event = {
+      type: "error",
+      code,
+      message,
+      details,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("error", event);
+    this.errorHandler?.(event);
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "sessionStarted":
+        this.sessionId = message.sessionId;
+        this.emit("sessionStarted", {
+          type: "sessionStarted",
+          sessionId: message.sessionId,
+          timestamp: message.timestamp
+        });
+        break;
+      case "sessionEnded":
+        this.sessionId = null;
+        this.sessionConfig = null;
+        this.emit("sessionEnded", {
+          type: "sessionEnded",
+          sessionId: message.sessionId,
+          timestamp: message.timestamp
+        });
+        break;
+      case "transcript": {
+        const transcriptEvent = {
+          type: "transcript",
+          text: message.text,
+          isFinal: message.isFinal,
+          timestamp: message.timestamp
+        };
+        if (message.confidence !== void 0) {
+          transcriptEvent.confidence = message.confidence;
+        }
+        this.emit("transcript", transcriptEvent);
+        this.transcriptHandler?.(message.text, message.isFinal);
+        break;
+      }
+      case "response": {
+        const responseEvent = {
+          type: "response",
+          text: message.text,
+          isFinal: message.isFinal,
+          timestamp: message.timestamp
+        };
+        this.emit("response", responseEvent);
+        this.responseHandler?.(message.text, message.isFinal);
+        break;
+      }
+      case "audio": {
+        const audioData = this.audioEncoder.decode(message.data);
+        const audioEvent = {
+          type: "audio",
+          data: audioData,
+          format: message.format,
+          sampleRate: message.sampleRate,
+          timestamp: message.timestamp
+        };
+        this.emit("audio", audioEvent);
+        this.audioHandler?.(audioData);
+        break;
+      }
+      case "error":
+        this.handleError(message.code, message.message, message.details);
+        break;
+      default:
+        this.logger.warn("Unknown message type:", message.type);
+    }
+  }
+};
+export {
+  AudioEncoder,
+  LiveSpeechClient,
+  Region,
+  createWavHeader,
+  decodeBase64ToAudio,
+  encodeAudioToBase64,
+  extractPcmFromWav,
+  float32ToInt16,
+  getEndpointForRegion,
+  int16ToFloat32,
+  int16ToUint8,
+  isValidRegion,
+  uint8ToInt16,
+  wrapPcmInWav
+};