@lokutor/sdk 1.1.9 → 1.1.11

package/dist/index.js

@@ -26,7 +26,6 @@ __export(index_exports, {
   Language: () => Language,
   StreamResampler: () => StreamResampler,
   TTSClient: () => TTSClient,
-  VoiceAgent: () => VoiceAgent,
   VoiceAgentClient: () => VoiceAgentClient,
   VoiceStyle: () => VoiceStyle,
   applyLowPassFilter: () => applyLowPassFilter,
@@ -79,289 +78,6 @@ var DEFAULT_URLS = {
   TTS: "wss://api.lokutor.com/ws/tts"
 };
 
-// src/client.ts
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const bytes = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes;
-}
-var VoiceAgentClient = class {
-  ws = null;
-  apiKey;
-  prompt;
-  voice;
-  language;
-  // Callbacks
-  onTranscription;
-  onResponse;
-  onAudioCallback;
-  onVisemesCallback;
-  onStatus;
-  onError;
-  isConnected = false;
-  messages = [];
-  visemeListeners = [];
-  wantVisemes = false;
-  serverUrl = null;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.prompt = config.prompt;
-    this.voice = config.voice || "F1" /* F1 */;
-    this.language = config.language || "en" /* ENGLISH */;
-    this.serverUrl = config.serverUrl || null;
-    this.onTranscription = config.onTranscription;
-    this.onResponse = config.onResponse;
-    this.onAudioCallback = config.onAudio;
-    this.onVisemesCallback = config.onVisemes;
-    this.onStatus = config.onStatus;
-    this.onError = config.onError;
-    this.wantVisemes = config.visemes || false;
-  }
-  /**
-   * Connect to the Lokutor Voice Agent server
-   */
-  async connect() {
-    return new Promise((resolve, reject) => {
-      try {
-        let url = this.serverUrl || DEFAULT_URLS.VOICE_AGENT;
-        if (this.apiKey) {
-          const separator = url.includes("?") ? "&" : "?";
-          url += `${separator}api_key=${this.apiKey}`;
-        }
-        console.log(`\u{1F517} Connecting to ${url}...`);
-        this.ws = new WebSocket(url);
-        this.ws.binaryType = "arraybuffer";
-        this.ws.onopen = () => {
-          this.isConnected = true;
-          console.log("\u2705 Connected to voice agent!");
-          this.sendConfig();
-          resolve(true);
-        };
-        this.ws.onmessage = async (event) => {
-          if (event.data instanceof ArrayBuffer) {
-            this.handleBinaryMessage(new Uint8Array(event.data));
-          } else {
-            this.handleTextMessage(event.data.toString());
-          }
-        };
-        this.ws.onerror = (err) => {
-          console.error("\u274C WebSocket error:", err);
-          if (this.onError) this.onError(err);
-          if (!this.isConnected) reject(err);
-        };
-        this.ws.onclose = () => {
-          this.isConnected = false;
-          console.log("Disconnected");
-        };
-      } catch (err) {
-        if (this.onError) this.onError(err);
-        reject(err);
-      }
-    });
-  }
-  /**
-   * Send initial configuration to the server
-   */
-  sendConfig() {
-    if (!this.ws || !this.isConnected) return;
-    this.ws.send(JSON.stringify({ type: "prompt", data: this.prompt }));
-    this.ws.send(JSON.stringify({ type: "voice", data: this.voice }));
-    this.ws.send(JSON.stringify({ type: "language", data: this.language }));
-    this.ws.send(JSON.stringify({ type: "visemes", data: this.wantVisemes }));
-    console.log(`\u2699\uFE0F Configured: voice=${this.voice}, language=${this.language}, visemes=${this.wantVisemes}`);
-  }
-  /**
-   * Send raw PCM audio data to the server
-   * @param audioData Int16 PCM audio buffer
-   */
-  sendAudio(audioData) {
-    if (this.ws && this.isConnected) {
-      this.ws.send(audioData);
-    }
-  }
-  /**
-   * Handle incoming binary data (audio response)
-   */
-  handleBinaryMessage(data) {
-    this.emit("audio", data);
-  }
-  /**
-   * Handle incoming text messages (metadata/transcriptions)
-   */
-  handleTextMessage(text) {
-    try {
-      const msg = JSON.parse(text);
-      switch (msg.type) {
-        case "audio":
-          if (msg.data) {
-            const buffer = base64ToUint8Array(msg.data);
-            this.handleBinaryMessage(buffer);
-          }
-          break;
-        case "transcript":
-          const role = msg.role === "user" ? "user" : "agent";
-          this.messages.push({
-            role,
-            text: msg.data,
-            timestamp: Date.now()
-          });
-          if (msg.role === "user") {
-            if (this.onTranscription) this.onTranscription(msg.data);
-            console.log(`\u{1F4AC} You: ${msg.data}`);
-          } else {
-            if (this.onResponse) this.onResponse(msg.data);
-            console.log(`\u{1F916} Agent: ${msg.data}`);
-          }
-          break;
-        case "status":
-          if (this.onStatus) this.onStatus(msg.data);
-          const icons = {
-            "interrupted": "\u26A1",
-            "thinking": "\u{1F9E0}",
-            "speaking": "\u{1F50A}",
-            "listening": "\u{1F442}"
-          };
-          console.log(`${icons[msg.data] || ""} Status: ${msg.data}`);
-          break;
-        case "visemes":
-          if (Array.isArray(msg.data) && msg.data.length > 0) {
-            this.emit("visemes", msg.data);
-          }
-          break;
-        case "error":
-          if (this.onError) this.onError(msg.data);
-          console.error(`\u274C Server error: ${msg.data}`);
-          break;
-      }
-    } catch (e) {
-    }
-  }
-  audioListeners = [];
-  emit(event, data) {
-    if (event === "audio") {
-      if (this.onAudioCallback) this.onAudioCallback(data);
-      this.audioListeners.forEach((l) => l(data));
-    } else if (event === "visemes") {
-      if (this.onVisemesCallback) this.onVisemesCallback(data);
-      this.visemeListeners.forEach((l) => l(data));
-    }
-  }
-  onAudio(callback) {
-    this.audioListeners.push(callback);
-  }
-  onVisemes(callback) {
-    this.visemeListeners.push(callback);
-  }
-  /**
-   * Disconnect from the server
-   */
-  disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  /**
-   * Update the system prompt mid-conversation
-   */
-  updatePrompt(newPrompt) {
-    this.prompt = newPrompt;
-    if (this.ws && this.isConnected) {
-      try {
-        this.ws.send(JSON.stringify({ type: "prompt", data: newPrompt }));
-        console.log(`\u2699\uFE0F Updated prompt: ${newPrompt.substring(0, 50)}...`);
-      } catch (error) {
-        console.error("Error updating prompt:", error);
-      }
-    } else {
-      console.warn("Not connected - prompt will be updated on next connection");
-    }
-  }
-  /**
-   * Get full conversation transcript
-   */
-  getTranscript() {
-    return this.messages.slice();
-  }
-  /**
-   * Get conversation as formatted text
-   */
-  getTranscriptText() {
-    return this.messages.map((msg) => `${msg.role === "user" ? "You" : "Agent"}: ${msg.text}`).join("\n");
-  }
-};
-var TTSClient = class {
-  apiKey;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-  }
-  /**
-   * Synthesize text to speech
-   * 
-   * This opens a temporary WebSocket connection, sends the request, 
-   * and streams back the audio.
-   */
-  synthesize(options) {
-    return new Promise((resolve, reject) => {
-      try {
-        let url = DEFAULT_URLS.TTS;
-        if (this.apiKey) {
-          const separator = url.includes("?") ? "&" : "?";
-          url += `${separator}api_key=${this.apiKey}`;
-        }
-        const ws = new WebSocket(url);
-        ws.binaryType = "arraybuffer";
-        ws.onopen = () => {
-          const req = {
-            text: options.text,
-            voice: options.voice || "F1" /* F1 */,
-            lang: options.language || "en" /* ENGLISH */,
-            speed: options.speed || 1.05,
-            steps: options.steps || 24,
-            visemes: options.visemes || false
-          };
-          ws.send(JSON.stringify(req));
-        };
-        ws.onmessage = async (event) => {
-          if (event.data instanceof ArrayBuffer) {
-            if (options.onAudio) options.onAudio(new Uint8Array(event.data));
-          } else {
-            try {
-              const msg = JSON.parse(event.data.toString());
-              if (Array.isArray(msg) && options.onVisemes) {
-                options.onVisemes(msg);
-              }
-            } catch (e) {
-            }
-          }
-        };
-        ws.onerror = (err) => {
-          if (options.onError) options.onError(err);
-          reject(err);
-        };
-        ws.onclose = () => {
-          resolve();
-        };
-      } catch (err) {
-        if (options.onError) options.onError(err);
-        reject(err);
-      }
-    });
-  }
-};
-async function simpleConversation(config) {
-  const client = new VoiceAgentClient(config);
-  await client.connect();
-  return client;
-}
-async function simpleTTS(options) {
-  const client = new TTSClient({ apiKey: options.apiKey });
-  return client.synthesize(options);
-}
-
 // src/audio-utils.ts
 function pcm16ToFloat32(int16Data) {
   const float32 = new Float32Array(int16Data.length);
@@ -501,11 +217,11 @@ var BrowserAudioManager = class {
   scriptProcessor = null;
   analyserNode = null;
   mediaStream = null;
+  resampler = null;
   // Playback scheduling
   nextPlaybackTime = 0;
   activeSources = [];
-  // High-precision clock anchor for viseme sync
-  audioClockOffset = null;
+  playbackQueue = [];
   // Configuration
   inputSampleRate;
   outputSampleRate;
@@ -518,7 +234,6 @@ var BrowserAudioManager = class {
   // Audio processing state
   isMuted = false;
   isListening = false;
-  resampler = null;
   constructor(config = {}) {
     this.inputSampleRate = config.inputSampleRate ?? AUDIO_CONFIG.SAMPLE_RATE;
     this.outputSampleRate = config.outputSampleRate ?? AUDIO_CONFIG.SPEAKER_SAMPLE_RATE;
@@ -542,6 +257,7 @@ var BrowserAudioManager = class {
     }
     if (this.audioContext.state === "suspended") {
       await this.audioContext.resume();
+      console.log("\u{1F442} AudioContext resumed");
     }
     if (analyserConfig?.enabled !== false) {
       this.analyserNode = this.audioContext.createAnalyser();
@@ -555,7 +271,6 @@ var BrowserAudioManager = class {
     if (!this.audioContext) {
       await this.init();
     }
-    this.resampler = new StreamResampler(this.audioContext.sampleRate, this.inputSampleRate);
     try {
       this.onAudioInput = onAudioInput;
       this.isListening = true;
@@ -571,13 +286,21 @@ var BrowserAudioManager = class {
       this.scriptProcessor = this.audioContext.createScriptProcessor(
         bufferSize,
         1,
+        // input channels
         1
+        // output channels
       );
       this.mediaStreamAudioSourceNode.connect(this.scriptProcessor);
       this.scriptProcessor.connect(this.audioContext.destination);
       if (this.analyserNode) {
         this.mediaStreamAudioSourceNode.connect(this.analyserNode);
       }
+      const hardwareRate = this.audioContext.sampleRate;
+      if (hardwareRate !== this.inputSampleRate) {
+        this.resampler = new StreamResampler(hardwareRate, this.inputSampleRate);
+      } else {
+        this.resampler = null;
+      }
       this.scriptProcessor.onaudioprocess = (event) => {
         this._processAudioInput(event);
       };
@@ -588,19 +311,36 @@ var BrowserAudioManager = class {
       throw err;
     }
   }
+  /**
+   * Internal method to process microphone audio data
+   */
   _processAudioInput(event) {
-    if (!this.onAudioInput || !this.audioContext || !this.isListening || this.isMuted) return;
-    const inputData = event.inputBuffer.getChannelData(0);
-    event.outputBuffer.getChannelData(0).fill(0);
-    const resampled = this.resampler ? this.resampler.process(inputData) : inputData;
-    if (resampled && resampled.length > 0) {
-      const int16Data = float32ToPcm16(resampled);
-      this.onAudioInput(new Uint8Array(int16Data.buffer, int16Data.byteOffset, int16Data.byteLength));
+    if (!this.onAudioInput || !this.audioContext || !this.isListening) return;
+    if (this.isMuted) return;
+    const inputBuffer = event.inputBuffer;
+    const inputData = inputBuffer.getChannelData(0);
+    const outputBuffer = event.outputBuffer;
+    for (let i = 0; i < outputBuffer.getChannelData(0).length; i++) {
+      outputBuffer.getChannelData(0)[i] = 0;
+    }
+    let processedData = new Float32Array(inputData);
+    if (this.resampler) {
+      processedData = this.resampler.process(processedData);
     }
+    if (processedData.length === 0) return;
+    const int16Data = float32ToPcm16(processedData);
+    const uint8Data = new Uint8Array(
+      int16Data.buffer,
+      int16Data.byteOffset,
+      int16Data.byteLength
+    );
+    this.onAudioInput(uint8Data);
   }
+  /**
+   * Stop capturing microphone input
+   */
   stopMicrophone() {
     this.isListening = false;
-    this.resampler = null;
     if (this.mediaStream) {
       this.mediaStream.getTracks().forEach((track) => track.stop());
       this.mediaStream = null;
@@ -613,12 +353,17 @@ var BrowserAudioManager = class {
       this.mediaStreamAudioSourceNode.disconnect();
       this.mediaStreamAudioSourceNode = null;
     }
+    console.log("\u{1F3A4} Microphone stopped");
   }
   /**
    * Play back audio received from the server
+   * @param pcm16Data Int16 PCM audio data at SPEAKER_SAMPLE_RATE
    */
   playAudio(pcm16Data) {
-    if (!this.audioContext) return;
+    if (!this.audioContext) {
+      console.warn("AudioContext not initialized");
+      return;
+    }
     const int16Array = new Int16Array(
       pcm16Data.buffer,
       pcm16Data.byteOffset,
@@ -633,17 +378,18 @@ var BrowserAudioManager = class {
     audioBuffer.getChannelData(0).set(float32Data);
     this._schedulePlayback(audioBuffer);
   }
+  /**
+   * Internal method to schedule and play audio with sample-accurate timing
+   */
   _schedulePlayback(audioBuffer) {
     if (!this.audioContext) return;
     const currentTime = this.audioContext.currentTime;
     const duration = audioBuffer.length / this.outputSampleRate;
     const startTime = Math.max(
       currentTime + 0.01,
+      // Minimum 10ms delay
       this.nextPlaybackTime
     );
-    if (this.audioClockOffset === null) {
-      this.audioClockOffset = startTime;
-    }
     this.nextPlaybackTime = startTime + duration;
     const source = this.audioContext.createBufferSource();
     source.buffer = audioBuffer;
@@ -658,185 +404,441 @@ var BrowserAudioManager = class {
       if (index > -1) {
         this.activeSources.splice(index, 1);
       }
-    };
+    };
+  }
+  /**
+   * Stop all currently playing audio and clear the queue
+   */
+  stopPlayback() {
+    this.activeSources.forEach((source) => {
+      try {
+        source.stop();
+      } catch (e) {
+      }
+    });
+    this.activeSources = [];
+    this.playbackQueue = [];
+    this.nextPlaybackTime = this.audioContext?.currentTime ?? 0;
+    console.log("\u{1F507} Playback stopped");
+  }
+  /**
+   * Toggle mute state
+   */
+  setMuted(muted) {
+    this.isMuted = muted;
+  }
+  /**
+   * Get current mute state
+   */
+  isMicMuted() {
+    return this.isMuted;
+  }
+  /**
+   * Get current amplitude from analyser (for visualization)
+   * Returns value between 0 and 1
+   */
+  getAmplitude() {
+    if (!this.analyserNode) return 0;
+    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
+    this.analyserNode.getByteTimeDomainData(dataArray);
+    const rms = calculateRMS(dataArray);
+    return Math.min(rms * 10, 1);
+  }
+  /**
+   * Get frequency data from analyser for visualization
+   */
+  getFrequencyData() {
+    if (!this.analyserNode) {
+      return new Uint8Array(0);
+    }
+    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
+    this.analyserNode.getByteFrequencyData(dataArray);
+    return dataArray;
+  }
+  /**
+   * Get time-domain data from analyser for waveform visualization
+   */
+  getWaveformData() {
+    if (!this.analyserNode) {
+      return new Uint8Array(0);
+    }
+    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
+    this.analyserNode.getByteTimeDomainData(dataArray);
+    return dataArray;
+  }
+  /**
+   * Cleanup and close AudioContext
+   */
+  cleanup() {
+    this.stopMicrophone();
+    this.stopPlayback();
+    if (this.analyserNode) {
+      this.analyserNode.disconnect();
+      this.analyserNode = null;
+    }
+  }
+  /**
+   * Get current audio context state
+   */
+  getState() {
+    return this.audioContext?.state ?? null;
+  }
+  /**
+   * Check if microphone is currently listening
+   */
+  isRecording() {
+    return this.isListening;
+  }
+};
+
+// src/client.ts
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+var VoiceAgentClient = class {
+  ws = null;
+  apiKey;
+  prompt;
+  voice;
+  language;
+  // Callbacks
+  onTranscription;
+  onResponse;
+  onAudioCallback;
+  onVisemesCallback;
+  onStatus;
+  onError;
+  isConnected = false;
+  messages = [];
+  visemeListeners = [];
+  wantVisemes = false;
+  audioManager = null;
+  enableAudio = false;
+  // Connection resilience
+  isUserDisconnect = false;
+  reconnecting = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.prompt = config.prompt;
+    this.voice = config.voice || "F1" /* F1 */;
+    this.language = config.language || "en" /* ENGLISH */;
+    this.onTranscription = config.onTranscription;
+    this.onResponse = config.onResponse;
+    this.onAudioCallback = config.onAudio;
+    this.onVisemesCallback = config.onVisemes;
+    this.onStatus = config.onStatus;
+    this.onError = config.onError;
+    this.wantVisemes = config.visemes || false;
+    this.enableAudio = config.enableAudio ?? false;
+  }
+  /**
+   * Connect to the Lokutor Voice Agent server
+   */
+  async connect() {
+    this.isUserDisconnect = false;
+    if (this.enableAudio) {
+      if (!this.audioManager) {
+        this.audioManager = new BrowserAudioManager();
+      }
+      await this.audioManager.init();
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        let url = DEFAULT_URLS.VOICE_AGENT;
+        if (this.apiKey) {
+          const separator = url.includes("?") ? "&" : "?";
+          url += `${separator}api_key=${this.apiKey}`;
+        }
+        console.log(`\u{1F517} Connecting to ${DEFAULT_URLS.VOICE_AGENT}...`);
+        this.ws = new WebSocket(url);
+        this.ws.binaryType = "arraybuffer";
+        this.ws.onopen = async () => {
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          this.reconnecting = false;
+          console.log("\u2705 Connected to voice agent!");
+          this.sendConfig();
+          if (this.audioManager) {
+            await this.audioManager.startMicrophone((data) => {
+              if (this.isConnected) {
+                this.sendAudio(data);
+              }
+            });
+          }
+          resolve(true);
+        };
+        this.ws.onmessage = async (event) => {
+          if (event.data instanceof ArrayBuffer) {
+            this.handleBinaryMessage(new Uint8Array(event.data));
+          } else {
+            this.handleTextMessage(event.data.toString());
+          }
+        };
+        this.ws.onerror = (err) => {
+          console.error("\u274C WebSocket error:", err);
+          if (this.onError) this.onError(err);
+          if (!this.isConnected) reject(err);
+        };
+        this.ws.onclose = () => {
+          this.isConnected = false;
+          if (!this.isUserDisconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnecting = true;
+            this.reconnectAttempts++;
+            const backoffDelay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 1e4);
+            console.warn(`Connection lost. Reconnecting in ${backoffDelay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            if (this.onStatus) this.onStatus("reconnecting");
+            setTimeout(() => {
+              this.connect().catch((e) => console.error("Reconnect failed", e));
+            }, backoffDelay);
+          } else {
+            console.log("Disconnected");
+            if (this.onStatus) this.onStatus("disconnected");
+          }
+        };
+      } catch (err) {
+        if (this.onError) this.onError(err);
+        reject(err);
+      }
+    });
   }
   /**
-   * Get the current high-precision audio clock offset for viseme synchronization.
-   * Total stream time (in ms) = (audioContext.currentTime - audioClockOffset) * 1000
+   * Send initial configuration to the server
    */
-  getAudioClockOffset() {
-    return this.audioClockOffset;
+  sendConfig() {
+    if (!this.ws || !this.isConnected) return;
+    this.ws.send(JSON.stringify({ type: "prompt", data: this.prompt }));
+    this.ws.send(JSON.stringify({ type: "voice", data: this.voice }));
+    this.ws.send(JSON.stringify({ type: "language", data: this.language }));
+    this.ws.send(JSON.stringify({ type: "visemes", data: this.wantVisemes }));
+    console.log(`\u2699\uFE0F Configured: voice=${this.voice}, language=${this.language}, visemes=${this.wantVisemes}`);
   }
   /**
-   * Reset the audio clock offset (call when a response is interrupted or finished)
+   * Send raw PCM audio data to the server
+   * @param audioData Int16 PCM audio buffer
    */
-  resetAudioClock() {
-    this.audioClockOffset = null;
-  }
-  stopPlayback() {
-    this.activeSources.forEach((source) => {
-      try {
-        source.stop();
-      } catch (e) {
-      }
-    });
-    this.activeSources = [];
-    this.nextPlaybackTime = 0;
-    this.resetAudioClock();
+  sendAudio(audioData) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.isConnected) {
+      this.ws.send(audioData);
+    }
   }
-  setMuted(muted) {
-    this.isMuted = muted;
+  /**
+   * Handle incoming binary data (audio response)
+   */
+  handleBinaryMessage(data) {
+    if (this.audioManager) {
+      this.audioManager.playAudio(data);
+    }
+    this.emit("audio", data);
   }
-  isMicMuted() {
-    return this.isMuted;
+  /**
+   * Handle incoming text messages (metadata/transcriptions)
+   */
+  handleTextMessage(text) {
+    try {
+      const msg = JSON.parse(text);
+      switch (msg.type) {
+        case "audio":
+          if (msg.data) {
+            const buffer = base64ToUint8Array(msg.data);
+            this.handleBinaryMessage(buffer);
+          }
+          break;
+        case "transcript":
+          const role = msg.role === "user" ? "user" : "agent";
+          this.messages.push({
+            role,
+            text: msg.data,
+            timestamp: Date.now()
+          });
+          if (msg.role === "user") {
+            if (this.onTranscription) this.onTranscription(msg.data);
+            console.log(`\u{1F4AC} You: ${msg.data}`);
+          } else {
+            if (this.onResponse) this.onResponse(msg.data);
+            console.log(`\u{1F916} Agent: ${msg.data}`);
+          }
+          break;
+        case "status":
+          if (msg.data === "interrupted" && this.audioManager) {
+            this.audioManager.stopPlayback();
+          }
+          if (this.onStatus) this.onStatus(msg.data);
+          const icons = {
+            "interrupted": "\u26A1",
+            "thinking": "\u{1F9E0}",
+            "speaking": "\u{1F50A}",
+            "listening": "\u{1F442}"
+          };
+          console.log(`${icons[msg.data] || ""} Status: ${msg.data}`);
+          break;
+        case "visemes":
+          if (Array.isArray(msg.data) && msg.data.length > 0) {
+            this.emit("visemes", msg.data);
+          }
+          break;
+        case "error":
+          if (this.onError) this.onError(msg.data);
+          console.error(`\u274C Server error: ${msg.data}`);
+          break;
+      }
+    } catch (e) {
+    }
   }
-  getAmplitude() {
-    if (!this.analyserNode) return 0;
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteTimeDomainData(dataArray);
-    const rms = calculateRMS(dataArray);
-    return Math.min(rms * 10, 1);
+  audioListeners = [];
+  emit(event, data) {
+    if (event === "audio") {
+      if (this.onAudioCallback) this.onAudioCallback(data);
+      this.audioListeners.forEach((l) => l(data));
+    } else if (event === "visemes") {
+      if (this.onVisemesCallback) this.onVisemesCallback(data);
+      this.visemeListeners.forEach((l) => l(data));
+    }
   }
-  getFrequencyData() {
-    if (!this.analyserNode) return new Uint8Array(0);
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteFrequencyData(dataArray);
-    return dataArray;
+  onAudio(callback) {
+    this.audioListeners.push(callback);
   }
-  getWaveformData() {
-    if (!this.analyserNode) return new Uint8Array(0);
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteTimeDomainData(dataArray);
-    return dataArray;
+  onVisemes(callback) {
+    this.visemeListeners.push(callback);
   }
-  cleanup() {
-    this.stopMicrophone();
-    this.stopPlayback();
-    if (this.analyserNode) {
-      this.analyserNode.disconnect();
-      this.analyserNode = null;
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    this.isUserDisconnect = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
     }
-  }
-  getAudioContext() {
-    return this.audioContext;
-  }
-};
-
-// src/voice-agent.ts
-var VoiceAgent = class {
-  client;
-  audioManager;
-  options;
-  isConnected = false;
-  visemeQueue = [];
-  constructor(options) {
-    this.options = options;
-    this.client = new VoiceAgentClient({
-      apiKey: options.apiKey,
-      prompt: options.prompt || "You are a helpful and friendly AI assistant.",
-      voice: options.voice || "F1" /* F1 */,
-      language: options.language || "en" /* ENGLISH */,
-      visemes: options.visemes ?? true,
-      serverUrl: options.serverUrl,
-      onTranscription: (text) => {
-        if (options.onTranscription) options.onTranscription(text, true);
-      },
-      onResponse: (text) => {
-        if (options.onTranscription) options.onTranscription(text, false);
-      },
-      onAudio: (data) => {
-        this.audioManager.playAudio(data);
-      },
-      onVisemes: (visemes) => {
-        this.visemeQueue.push(...visemes);
-        if (options.onVisemes) options.onVisemes(visemes);
-      },
-      onStatus: (status) => {
-        if (options.onStatusChange) options.onStatusChange(status);
-        if (status === "interrupted" || status === "thinking") {
-          this.audioManager.stopPlayback();
-          this.visemeQueue = [];
-        }
-      },
-      onError: (err) => {
-        if (options.onError) options.onError(err);
-      }
-    });
-    this.audioManager = new BrowserAudioManager({
-      autoGainControl: true,
-      echoCancellation: true,
-      noiseSuppression: true
-    });
+    if (this.audioManager) {
+      this.audioManager.cleanup();
+    }
+    this.isConnected = false;
   }
   /**
-   * Initialize hardware and connect to the AI server.
-   * This must be called in response to a user guesture (like a click)
-   * to satisfy browser AudioContext requirements.
+   * Toggles the microphone mute state (if managed by client)
+   * returns the new mute state
    */
-  async connect() {
-    try {
-      await this.audioManager.init();
-      const connected = await this.client.connect();
-      if (!connected) return false;
-      this.isConnected = true;
-      await this.audioManager.startMicrophone((pcm16Data) => {
-        if (this.isConnected) {
-          this.client.sendAudio(pcm16Data);
-        }
-      });
-      return true;
-    } catch (err) {
-      if (this.options.onError) this.options.onError(err);
-      return false;
+  toggleMute() {
+    if (this.audioManager) {
+      const isMuted = this.audioManager.isMicMuted();
+      this.audioManager.setMuted(!isMuted);
+      return !isMuted;
     }
+    return false;
   }
   /**
-   * Get the current amplitude/volume of the microphone or output audio.
-   * Useful for voice activity visualization.
-   * @returns value between 0 and 1
+   * Gets the microphone volume amplitude 0-1 (if managed by client)
    */
   getAmplitude() {
-    return this.audioManager.getAmplitude();
+    if (this.audioManager) {
+      return this.audioManager.getAmplitude();
+    }
+    return 0;
   }
   /**
-   * Mute or unmute the microphone.
+   * Update the system prompt mid-conversation
    */
-  toggleMute() {
-    const currentState = this.audioManager.isMicMuted();
-    this.audioManager.setMuted(!currentState);
-    return !currentState;
+  updatePrompt(newPrompt) {
+    this.prompt = newPrompt;
+    if (this.ws && this.isConnected) {
+      try {
+        this.ws.send(JSON.stringify({ type: "prompt", data: newPrompt }));
+        console.log(`\u2699\uFE0F Updated prompt: ${newPrompt.substring(0, 50)}...`);
+      } catch (error) {
+        console.error("Error updating prompt:", error);
+      }
+    } else {
+      console.warn("Not connected - prompt will be updated on next connection");
+    }
   }
   /**
-   * High-precision method to get visemes that should be active 
-   * at the current playback frame. Use this in a requestAnimationFrame loop.
+   * Get full conversation transcript
    */
-  getFrameVisemes() {
-    const offset = this.audioManager.getAudioClockOffset();
-    const audioCtx = this.audioManager.getAudioContext();
-    if (offset === null || !audioCtx) return [];
-    const streamTime = (audioCtx.currentTime - offset) * 1e3;
-    const currentBatch = [];
-    while (this.visemeQueue.length > 0 && this.visemeQueue[0].t * 1e3 <= streamTime) {
-      currentBatch.push(this.visemeQueue.shift());
-    }
-    return currentBatch;
+  getTranscript() {
+    return this.messages.slice();
   }
   /**
-   * Change the system prompt mid-conversation.
+   * Get conversation as formatted text
    */
-  updatePrompt(newPrompt) {
-    this.client.updatePrompt(newPrompt);
+  getTranscriptText() {
+    return this.messages.map((msg) => `${msg.role === "user" ? "You" : "Agent"}: ${msg.text}`).join("\n");
+  }
+};
+var TTSClient = class {
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.apiKey;
   }
   /**
-   * Disconnect and release audio resources.
+   * Synthesize text to speech
+   * 
+   * This opens a temporary WebSocket connection, sends the request, 
+   * and streams back the audio.
    */
-  disconnect() {
-    this.isConnected = false;
-    this.client.disconnect();
-    this.audioManager.cleanup();
-    this.visemeQueue = [];
+  synthesize(options) {
+    return new Promise((resolve, reject) => {
+      try {
+        let url = DEFAULT_URLS.TTS;
+        if (this.apiKey) {
+          const separator = url.includes("?") ? "&" : "?";
+          url += `${separator}api_key=${this.apiKey}`;
+        }
+        const ws = new WebSocket(url);
+        ws.binaryType = "arraybuffer";
+        ws.onopen = () => {
+          const req = {
+            text: options.text,
+            voice: options.voice || "F1" /* F1 */,
+            lang: options.language || "en" /* ENGLISH */,
+            speed: options.speed || 1.05,
+            steps: options.steps || 24,
+            visemes: options.visemes || false
+          };
+          ws.send(JSON.stringify(req));
+        };
+        ws.onmessage = async (event) => {
+          if (event.data instanceof ArrayBuffer) {
+            if (options.onAudio) options.onAudio(new Uint8Array(event.data));
+          } else {
+            try {
+              const msg = JSON.parse(event.data.toString());
+              if (Array.isArray(msg) && options.onVisemes) {
+                options.onVisemes(msg);
+              }
+            } catch (e) {
+            }
+          }
+        };
+        ws.onerror = (err) => {
+          if (options.onError) options.onError(err);
+          reject(err);
+        };
+        ws.onclose = () => {
+          resolve();
+        };
+      } catch (err) {
+        if (options.onError) options.onError(err);
+        reject(err);
+      }
+    });
   }
 };
+async function simpleConversation(config) {
+  const client = new VoiceAgentClient(config);
+  await client.connect();
+  return client;
+}
+async function simpleTTS(options) {
+  const client = new TTSClient({ apiKey: options.apiKey });
+  return client.synthesize(options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AUDIO_CONFIG,
@@ -845,7 +847,6 @@ var VoiceAgent = class {
   Language,
   StreamResampler,
   TTSClient,
-  VoiceAgent,
   VoiceAgentClient,
   VoiceStyle,
   applyLowPassFilter,