@lokutor/sdk 1.1.10 → 1.1.12

package/dist/index.mjs

@@ -34,287 +34,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;
-  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;
-  }
-  /**
-   * Connect to the Lokutor Voice Agent server
-   */
-  async connect() {
-    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 = () => {
-          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);
@@ -454,6 +173,7 @@ var BrowserAudioManager = class {
   scriptProcessor = null;
   analyserNode = null;
   mediaStream = null;
+  resampler = null;
   // Playback scheduling
   nextPlaybackTime = 0;
   activeSources = [];
@@ -531,6 +251,12 @@ var BrowserAudioManager = class {
       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);
       };
@@ -553,15 +279,11 @@ var BrowserAudioManager = class {
     for (let i = 0; i < outputBuffer.getChannelData(0).length; i++) {
       outputBuffer.getChannelData(0)[i] = 0;
     }
-    const hardwareRate = this.audioContext.sampleRate;
     let processedData = new Float32Array(inputData);
-    if (hardwareRate !== this.inputSampleRate) {
-      processedData = resampleWithAntiAliasing(
-        processedData,
-        hardwareRate,
-        this.inputSampleRate
-      );
+    if (this.resampler) {
+      processedData = this.resampler.process(processedData);
     }
+    if (processedData.length === 0) return;
     const int16Data = float32ToPcm16(processedData);
     const uint8Data = new Uint8Array(
       int16Data.buffer,
@@ -613,117 +335,487 @@ var BrowserAudioManager = class {
     this._schedulePlayback(audioBuffer);
   }
   /**
-   * Internal method to schedule and play audio with sample-accurate timing
+   * 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
+    );
+    this.nextPlaybackTime = startTime + duration;
+    const source = this.audioContext.createBufferSource();
+    source.buffer = audioBuffer;
+    source.connect(this.audioContext.destination);
+    if (this.analyserNode) {
+      source.connect(this.analyserNode);
+    }
+    source.start(startTime);
+    this.activeSources.push(source);
+    source.onended = () => {
+      const index = this.activeSources.indexOf(source);
+      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;
+  tools = [];
+  // Callbacks
+  onTranscription;
+  onResponse;
+  onAudioCallback;
+  onVisemesCallback;
+  onStatus;
+  onError;
+  isConnected = false;
+  messages = [];
+  visemeListeners = [];
+  wantVisemes = false;
+  audioManager = null;
+  enableAudio = false;
+  currentGeneration = 0;
+  // 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;
+    this.tools = config.tools || [];
+  }
+  /**
+   * 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);
+      }
+    });
+  }
+  /**
+   * Send initial configuration to the server
    */
-  _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
-    );
-    this.nextPlaybackTime = startTime + duration;
-    const source = this.audioContext.createBufferSource();
-    source.buffer = audioBuffer;
-    source.connect(this.audioContext.destination);
-    if (this.analyserNode) {
-      source.connect(this.analyserNode);
+  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 }));
+    if (this.tools && this.tools.length > 0) {
+      this.ws.send(JSON.stringify({ type: "tools", data: this.tools }));
     }
-    source.start(startTime);
-    this.activeSources.push(source);
-    source.onended = () => {
-      const index = this.activeSources.indexOf(source);
-      if (index > -1) {
-        this.activeSources.splice(index, 1);
-      }
-    };
+    console.log(`\u2699\uFE0F Configured: voice=${this.voice}, language=${this.language}, visemes=${this.wantVisemes}, tools=${this.tools.length}`);
   }
   /**
-   * Stop all currently playing audio and clear the queue
+   * Send raw PCM audio data to the server
+   * @param audioData Int16 PCM audio buffer
    */
-  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");
+  sendAudio(audioData) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.isConnected) {
+      this.ws.send(audioData);
+    }
   }
   /**
-   * Toggle mute state
+   * Handle incoming binary data (audio response)
    */
-  setMuted(muted) {
-    this.isMuted = muted;
+  handleBinaryMessage(data, generation) {
+    if (generation !== void 0 && generation < this.currentGeneration) {
+      console.log(`\u{1F5D1}\uFE0F Discarding ghost audio (Gen ${generation} < ${this.currentGeneration})`);
+      return;
+    }
+    if (this.audioManager) {
+      this.audioManager.playAudio(data);
+    }
+    this.emit("audio", data);
   }
   /**
-   * Get current mute state
+   * Handle incoming text messages (metadata/transcriptions)
    */
-  isMicMuted() {
-    return this.isMuted;
+  handleTextMessage(text) {
+    try {
+      const msg = JSON.parse(text);
+      switch (msg.type) {
+        case "audio":
+          if (msg.data) {
+            const buffer = base64ToUint8Array(msg.data);
+            this.handleBinaryMessage(buffer, msg.generation);
+          }
+          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 === "thinking") {
+            const newGen = msg.generation || 0;
+            if (newGen > this.currentGeneration) {
+              console.log(`\u{1F9E0} New thought (Gen ${newGen}) - Clearing audio queue`);
+              this.currentGeneration = newGen;
+              if (this.audioManager) this.audioManager.stopPlayback();
+            }
+          }
+          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;
+        case "tool_call":
+          console.log(`\u{1F6E0}\uFE0F Tool Call: ${msg.name}(${msg.arguments})`);
+          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);
   }
   /**
-   * Get current amplitude from analyser (for visualization)
-   * Returns value between 0 and 1
+   * Disconnect from the server
    */
-  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);
+  disconnect() {
+    this.isUserDisconnect = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.audioManager) {
+      this.audioManager.cleanup();
+    }
+    this.isConnected = false;
   }
   /**
-   * Get frequency data from analyser for visualization
+   * Toggles the microphone mute state (if managed by client)
+   * returns the new mute state
    */
-  getFrequencyData() {
-    if (!this.analyserNode) {
-      return new Uint8Array(0);
+  toggleMute() {
+    if (this.audioManager) {
+      const isMuted = this.audioManager.isMicMuted();
+      this.audioManager.setMuted(!isMuted);
+      return !isMuted;
     }
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteFrequencyData(dataArray);
-    return dataArray;
+    return false;
   }
   /**
-   * Get time-domain data from analyser for waveform visualization
+   * Gets the microphone volume amplitude 0-1 (if managed by client)
    */
-  getWaveformData() {
-    if (!this.analyserNode) {
-      return new Uint8Array(0);
+  getAmplitude() {
+    if (this.audioManager) {
+      return this.audioManager.getAmplitude();
     }
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteTimeDomainData(dataArray);
-    return dataArray;
+    return 0;
   }
   /**
-   * Cleanup and close AudioContext
+   * Update the system prompt mid-conversation
    */
-  cleanup() {
-    this.stopMicrophone();
-    this.stopPlayback();
-    if (this.analyserNode) {
-      this.analyserNode.disconnect();
-      this.analyserNode = null;
+  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 current audio context state
+   * Get full conversation transcript
    */
-  getState() {
-    return this.audioContext?.state ?? null;
+  getTranscript() {
+    return this.messages.slice();
   }
   /**
-   * Check if microphone is currently listening
+   * Get conversation as formatted text
    */
-  isRecording() {
-    return this.isListening;
+  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);
+}
 export {
   AUDIO_CONFIG,
   BrowserAudioManager,