@elevenlabs/client 1.1.2 → 1.2.1

package/dist/lib.iife.js

@@ -46,10 +46,11 @@ var ElevenLabsClient = (function(exports) {
 		constructor(options, connection) {
 			this.options = options;
 			this.connection = connection;
-			if (this.options.onConnect) this.options.onConnect({ conversationId: connection.conversationId });
 			this.connection.onMessage(this.onMessage);
 			this.connection.onDisconnect(this.endSessionWithDetails);
 			this.connection.onModeChange((mode) => this.updateMode(mode));
+		}
+		markConnected() {
 			this.updateStatus("connected");
 		}
 		endSession() {
@@ -383,7 +384,7 @@ var ElevenLabsClient = (function(exports) {
 	//#region src/sourceInfo.ts
 	let sourceInfo = Object.freeze({
 		name: "js_sdk",
-		version: "1.1.2"
+		version: "1.2.1"
 	});
 	//#endregion
 	//#region src/utils/events.ts
@@ -21929,6 +21930,66 @@ class RawAudioProcessor extends AudioWorkletProcessor {
 }
 registerProcessor("rawAudioProcessor", RawAudioProcessor);
 `);
+	//#endregion
+	//#region src/utils/calculateVolume.ts
+	/**
+	* Calculate a scalar volume level (0–1) from byte frequency data.
+	*
+	* The value is the mean of all frequency bins normalised to [0, 1].
+	*/
+	function calculateVolume(frequencyData) {
+		if (frequencyData.length === 0) return 0;
+		let volume = 0;
+		for (let i = 0; i < frequencyData.length; i++) volume += frequencyData[i] / 255;
+		volume /= frequencyData.length;
+		return volume < 0 ? 0 : volume > 1 ? 1 : volume;
+	}
+	//#endregion
+	//#region src/utils/volumeProvider.ts
+	const NO_VOLUME = {
+		getVolume: () => 0,
+		getByteFrequencyData: () => {}
+	};
+	const MAX_VOICE_FREQUENCY = 8e3;
+	/**
+	* Resamples the voice-relevant portion of raw frequency data into an output
+	* buffer using linear interpolation. This ensures both web and React Native
+	* return comparable frequency data focused on the human voice range.
+	*/
+	function resampleVoiceRange(raw, buffer, sampleRate) {
+		const binCount = raw.length;
+		const hzPerBin = sampleRate / 2 / binCount;
+		const minBin = Math.floor(100 / hzPerBin);
+		const maxBin = Math.min(Math.ceil(MAX_VOICE_FREQUENCY / hzPerBin), binCount);
+		const voiceBinCount = maxBin - minBin;
+		const outLen = buffer.length;
+		for (let i = 0; i < outLen; i++) {
+			const pos = i / outLen * voiceBinCount;
+			const lo = minBin + Math.floor(pos);
+			const hi = Math.min(lo + 1, maxBin - 1);
+			const t = pos - Math.floor(pos);
+			buffer[i] = Math.round(raw[lo] * (1 - t) + raw[hi] * t);
+		}
+	}
+	function createAnalyserVolumeProvider(analyser, sampleRate) {
+		const binCount = analyser.frequencyBinCount;
+		let rawData;
+		let voiceData;
+		return {
+			getVolume() {
+				rawData ??= new Uint8Array(binCount);
+				voiceData ??= new Uint8Array(binCount);
+				analyser.getByteFrequencyData(rawData);
+				resampleVoiceRange(rawData, voiceData, sampleRate);
+				return calculateVolume(voiceData);
+			},
+			getByteFrequencyData(buffer) {
+				rawData ??= new Uint8Array(binCount);
+				analyser.getByteFrequencyData(rawData);
+				resampleVoiceRange(rawData, buffer, sampleRate);
+			}
+		};
+	}
 	//#endregion
 	//#region src/utils/WebRTCConnection.ts
 	const DEFAULT_LIVEKIT_WS_URL = "wss://livekit.rtc.elevenlabs.io";
@@ -21946,8 +22007,11 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 		audioCaptureContext = null;
 		audioElements = [];
 		outputDeviceId = null;
+		inputAnalyser = null;
+		inputAudioContext = null;
+		inputVolumeProvider = NO_VOLUME;
 		outputAnalyser = null;
-		outputFrequencyData = null;
+		outputVolumeProvider = NO_VOLUME;
 		_isMuted = false;
 		input = {
 			close: async () => {
@@ -21970,6 +22034,7 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 					console.warn("Cannot set microphone muted: room not connected or no local participant");
 					return;
 				}
+				this._isMuted = isMuted;
 				const micTrackPublication = this.room.localParticipant.getTrackPublication(Track.Source.Microphone);
 				if (micTrackPublication?.track) try {
 					if (isMuted) await micTrackPublication.track.mute();
@@ -21978,10 +22043,24 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 					await this.room.localParticipant.setMicrophoneEnabled(!isMuted);
 				}
 				else await this.room.localParticipant.setMicrophoneEnabled(!isMuted);
-				this._isMuted = isMuted;
+				if (!isMuted) {
+					const track = this.room.localParticipant.getTrackPublication(Track.Source.Microphone)?.track;
+					if (track) this.setupInputAnalyser(track.mediaStreamTrack);
+				}
 			},
 			isMuted: () => this._isMuted,
-			getAnalyser: () => void 0
+			getAnalyser: () => this.inputAnalyser ?? void 0,
+			getVolume: () => {
+				if (this._isMuted) return 0;
+				return this.inputVolumeProvider.getVolume();
+			},
+			getByteFrequencyData: (buffer) => {
+				if (this._isMuted) {
+					buffer.fill(0);
+					return;
+				}
+				this.inputVolumeProvider.getByteFrequencyData(buffer);
+			}
 		};
 		output = {
 			close: async () => {},
@@ -21995,7 +22074,11 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 				this.setAudioVolume(volume);
 			},
 			interrupt: (_resetDuration) => {},
-			getAnalyser: () => this.outputAnalyser ?? void 0
+			getAnalyser: () => this.outputAnalyser ?? void 0,
+			getVolume: () => this.outputVolumeProvider.getVolume(),
+			getByteFrequencyData: (buffer) => {
+				this.outputVolumeProvider.getByteFrequencyData(buffer);
+			}
 		};
 		constructor(room, conversationId, inputFormat, outputFormat, config = {}) {
 			super(config);
@@ -22043,6 +22126,8 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 					}
 				});
 				await micEnabled;
+				const micTrack = room.localParticipant.getTrackPublication(Track.Source.Microphone)?.track;
+				if (micTrack) connection.setupInputAnalyser(micTrack.mediaStreamTrack);
 				if (room.name) connection.conversationId = room.name.match(/(conv_[a-zA-Z0-9]+)/)?.[0] || room.name;
 				const overridesEvent = constructOverrides(config);
 				connection.debug({
@@ -22126,6 +22211,13 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 				} catch (error) {
 					console.warn("Error stopping local tracks:", error);
 				}
+				if (this.inputAudioContext) {
+					this.inputAudioContext.close().catch((error) => {
+						console.warn("Error closing input audio context:", error);
+					});
+					this.inputAudioContext = null;
+					this.inputAnalyser = null;
+				}
 				if (this.audioCaptureContext) {
 					this.audioCaptureContext.close().catch((error) => {
 						console.warn("Error closing audio capture context:", error);
@@ -22162,6 +22254,35 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 		getRoom() {
 			return this.room;
 		}
+		/**
+		* (Re-)creates an AudioContext + AnalyserNode from the given track and
+		* installs the corresponding VolumeProvider. Called once during create()
+		* and again after an input device switch so the analyser follows the
+		* active mic track.
+		*/
+		setupInputAnalyser(mediaStreamTrack) {
+			if (this.inputAudioContext) {
+				this.inputAudioContext.close().catch(() => {});
+				this.inputAudioContext = null;
+				this.inputAnalyser = null;
+			}
+			try {
+				const ctx = new AudioContext();
+				const analyser = ctx.createAnalyser();
+				ctx.createMediaStreamSource(new MediaStream([mediaStreamTrack])).connect(analyser);
+				this.inputAnalyser = analyser;
+				this.inputAudioContext = ctx;
+				this.inputVolumeProvider = createAnalyserVolumeProvider(analyser, ctx.sampleRate);
+			} catch (error) {
+				console.warn("[ConversationalAI] Failed to set up input volume analyser:", error);
+			}
+		}
+		setInputVolumeProvider(provider) {
+			this.inputVolumeProvider = provider;
+		}
+		setOutputVolumeProvider(provider) {
+			this.outputVolumeProvider = provider;
+		}
 		async setupAudioCapture(track) {
 			try {
 				const audioContext = new AudioContext();
@@ -22172,6 +22293,7 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 				const mediaStream = new MediaStream([track.mediaStreamTrack]);
 				const source = audioContext.createMediaStreamSource(mediaStream);
 				source.connect(this.outputAnalyser);
+				this.setOutputVolumeProvider(createAnalyserVolumeProvider(this.outputAnalyser, audioContext.sampleRate));
 				await loadRawAudioProcessor(audioContext.audioWorklet);
 				const worklet = new AudioWorkletNode(audioContext, "rawAudioProcessor");
 				this.outputAnalyser.connect(worklet);
@@ -22236,6 +22358,7 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 					name: "microphone",
 					source: Track.Source.Microphone
 				});
+				this.setupInputAnalyser(audioTrack.mediaStreamTrack);
 			} catch (error) {
 				console.error("Failed to change input device:", error);
 				try {
@@ -22246,12 +22369,6 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 				throw error;
 			}
 		}
-		getOutputByteFrequencyData() {
-			if (!this.outputAnalyser) return null;
-			this.outputFrequencyData ??= new Uint8Array(this.outputAnalyser.frequencyBinCount);
-			this.outputAnalyser.getByteFrequencyData(this.outputFrequencyData);
-			return this.outputFrequencyData;
-		}
 	};
 	//#endregion
 	//#region src/utils/ConnectionFactory.ts
@@ -22299,7 +22416,7 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 	}
 	//#endregion
 	//#region src/TextConversation.ts
-	const EMPTY_FREQUENCY_DATA$1 = new Uint8Array(0);
+	const EMPTY_FREQUENCY_DATA = new Uint8Array(0);
 	var TextConversation = class TextConversation extends BaseConversation {
 		type = "text";
 		setVolume() {
@@ -22309,10 +22426,10 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 			throw new Error("setMicMuted is not supported in text conversations");
 		}
 		getInputByteFrequencyData() {
-			return EMPTY_FREQUENCY_DATA$1;
+			return EMPTY_FREQUENCY_DATA;
 		}
 		getOutputByteFrequencyData() {
-			return EMPTY_FREQUENCY_DATA$1;
+			return EMPTY_FREQUENCY_DATA;
 		}
 		getInputVolume() {
 			return 0;
@@ -22327,13 +22444,21 @@ registerProcessor("rawAudioProcessor", RawAudioProcessor);
 			if (fullOptions.onModeChange) fullOptions.onModeChange({ mode: "listening" });
 			if (fullOptions.onCanSendFeedbackChange) fullOptions.onCanSendFeedbackChange({ canSendFeedback: false });
 			let connection = null;
+			let conversation = null;
 			try {
 				await applyDelay(fullOptions.connectionDelay);
 				connection = await createConnection(fullOptions);
-				return new TextConversation(fullOptions, connection);
+				conversation = new TextConversation(fullOptions, connection);
+				fullOptions.onConversationCreated?.(conversation);
+				conversation.markConnected();
+				fullOptions.onConnect?.({ conversationId: connection.conversationId });
+				return conversation;
 			} catch (error) {
-				if (fullOptions.onStatusChange) fullOptions.onStatusChange({ status: "disconnected" });
-				connection?.close();
+				if (conversation) await conversation.endSession().catch(() => {});
+				else {
+					fullOptions.onStatusChange?.({ status: "disconnected" });
+					connection?.close();
+				}
 				throw error;
 			}
 		}
@@ -22498,6 +22623,7 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 		volume = 1;
 		interrupted = false;
 		interruptTimeout = null;
+		volumeProvider;
 		constructor(context, analyser, gain, worklet, audioElement) {
 			this.context = context;
 			this.analyser = analyser;
@@ -22505,10 +22631,17 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 			this.worklet = worklet;
 			this.audioElement = audioElement;
 			this.worklet.port.start();
+			this.volumeProvider = createAnalyserVolumeProvider(analyser, context.sampleRate);
 		}
 		getAnalyser() {
 			return this.analyser;
 		}
+		getVolume() {
+			return this.volumeProvider.getVolume();
+		}
+		getByteFrequencyData(buffer) {
+			this.volumeProvider.getByteFrequencyData(buffer);
+		}
 		addListener(listener) {
 			this.worklet.port.addEventListener("message", listener);
 		}
@@ -22617,6 +22750,7 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 			return isIosDevice() ? { ideal: deviceId } : { exact: deviceId };
 		}
 		muted = false;
+		volumeProvider;
 		constructor(context, analyser, worklet, inputStream, mediaStreamSource, permissions, onError = console.error) {
 			this.context = context;
 			this.analyser = analyser;
@@ -22627,10 +22761,22 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 			this.onError = onError;
 			this.permissions.addEventListener("change", this.handlePermissionsChange);
 			this.worklet.port.start();
+			this.volumeProvider = createAnalyserVolumeProvider(analyser, context.sampleRate);
 		}
 		getAnalyser() {
 			return this.analyser;
 		}
+		getVolume() {
+			if (this.muted) return 0;
+			return this.volumeProvider.getVolume();
+		}
+		getByteFrequencyData(buffer) {
+			if (this.muted) {
+				buffer.fill(0);
+				return;
+			}
+			this.volumeProvider.getByteFrequencyData(buffer);
+		}
 		isMuted() {
 			return this.muted;
 		}
@@ -22771,7 +22917,6 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 	let setupStrategy = webSessionSetup;
 	//#endregion
 	//#region src/VoiceConversation.ts
-	const EMPTY_FREQUENCY_DATA = new Uint8Array(0);
 	var VoiceConversation = class VoiceConversation extends BaseConversation {
 		type = "voice";
 		static async requestWakeLock() {
@@ -22785,6 +22930,7 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 			if (fullOptions.onStatusChange) fullOptions.onStatusChange({ status: "connecting" });
 			if (fullOptions.onCanSendFeedbackChange) fullOptions.onCanSendFeedbackChange({ canSendFeedback: false });
 			let preliminaryInputStream = null;
+			let conversation = null;
 			const useWakeLock = options.useWakeLock ?? true;
 			let wakeLock = null;
 			if (useWakeLock) wakeLock = await VoiceConversation.requestWakeLock();
@@ -22796,12 +22942,17 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 					track.stop();
 				});
 				preliminaryInputStream = null;
-				return new VoiceConversation(fullOptions, sessionSetup.connection, sessionSetup.input, sessionSetup.output, sessionSetup.playbackEventTarget, sessionSetup.detach, wakeLock);
+				conversation = new VoiceConversation(fullOptions, sessionSetup.connection, sessionSetup.input, sessionSetup.output, sessionSetup.playbackEventTarget, sessionSetup.detach, wakeLock);
+				fullOptions.onConversationCreated?.(conversation);
+				conversation.markConnected();
+				fullOptions.onConnect?.({ conversationId: sessionSetup.connection.conversationId });
+				return conversation;
 			} catch (error) {
-				if (fullOptions.onStatusChange) fullOptions.onStatusChange({ status: "disconnected" });
 				preliminaryInputStream?.getTracks().forEach((track) => {
 					track.stop();
 				});
+				if (conversation) await conversation.endSession().catch(() => {});
+				else fullOptions.onStatusChange?.({ status: "disconnected" });
 				try {
 					await wakeLock?.release();
 					wakeLock = null;
@@ -22860,42 +23011,27 @@ registerProcessor("audioConcatProcessor", AudioConcatProcessor);
 				this.updateMode("speaking");
 			}
 		}
-		calculateVolume = (frequencyData) => {
-			if (frequencyData.length === 0) return 0;
-			let volume = 0;
-			for (let i = 0; i < frequencyData.length; i++) volume += frequencyData[i] / 255;
-			volume /= frequencyData.length;
-			return volume < 0 ? 0 : volume > 1 ? 1 : volume;
-		};
+		static FREQUENCY_BIN_COUNT = 1024;
 		setMicMuted(isMuted) {
 			this.input.setMuted(isMuted).catch((error) => {
 				this.options.onError?.("Failed to set input muted state", error);
 			});
 		}
 		getInputByteFrequencyData() {
-			const analyser = this.input.getAnalyser();
-			if (!analyser) return EMPTY_FREQUENCY_DATA;
-			this.inputFrequencyData ??= new Uint8Array(analyser.frequencyBinCount);
-			analyser.getByteFrequencyData(this.inputFrequencyData);
+			this.inputFrequencyData ??= new Uint8Array(VoiceConversation.FREQUENCY_BIN_COUNT);
+			this.input.getByteFrequencyData(this.inputFrequencyData);
 			return this.inputFrequencyData;
 		}
 		getOutputByteFrequencyData() {
-			if (this.connection instanceof WebRTCConnection) {
-				const webrtcData = this.connection.getOutputByteFrequencyData();
-				if (webrtcData) return webrtcData;
-				return new Uint8Array(1024);
-			}
-			const analyser = this.output.getAnalyser();
-			if (!analyser) return EMPTY_FREQUENCY_DATA;
-			this.outputFrequencyData ??= new Uint8Array(analyser.frequencyBinCount);
-			analyser.getByteFrequencyData(this.outputFrequencyData);
+			this.outputFrequencyData ??= new Uint8Array(VoiceConversation.FREQUENCY_BIN_COUNT);
+			this.output.getByteFrequencyData(this.outputFrequencyData);
 			return this.outputFrequencyData;
 		}
 		getInputVolume() {
-			return this.calculateVolume(this.getInputByteFrequencyData());
+			return this.input.getVolume();
 		}
 		getOutputVolume() {
-			return this.calculateVolume(this.getOutputByteFrequencyData());
+			return this.output.getVolume();
 		}
 		async changeInputDevice({ sampleRate, format, preferHeadphonesForIosDevices, inputDeviceId }) {
 			try {