@elevenlabs/react 0.14.2 → 1.0.0-rc.0

package/dist/lib.iife.js

@@ -0,0 +1,984 @@
+var ElevenLabsReact = (function(exports, _elevenlabs_client_internal, _elevenlabs_client, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+	//#endregion
+	//#region src/version.ts
+	const PACKAGE_VERSION = "1.0.0-rc.0";
+	//#endregion
+	//#region src/scribe.ts
+	function useScribe(options = {}) {
+		const { onSessionStarted, onPartialTranscript, onCommittedTranscript, onCommittedTranscriptWithTimestamps, onError, onAuthError, onQuotaExceededError, onCommitThrottledError, onTranscriberError, onUnacceptedTermsError, onRateLimitedError, onInputError, onQueueOverflowError, onResourceExhaustedError, onSessionTimeLimitExceededError, onChunkSizeExceededError, onInsufficientAudioActivityError, onConnect, onDisconnect, token: defaultToken, modelId: defaultModelId, baseUri: defaultBaseUri, commitStrategy: defaultCommitStrategy, vadSilenceThresholdSecs: defaultVadSilenceThresholdSecs, vadThreshold: defaultVadThreshold, minSpeechDurationMs: defaultMinSpeechDurationMs, minSilenceDurationMs: defaultMinSilenceDurationMs, languageCode: defaultLanguageCode, microphone: defaultMicrophone, audioFormat: defaultAudioFormat, sampleRate: defaultSampleRate, autoConnect = false, includeTimestamps: defaultIncludeTimestamps } = options;
+		const connectionRef = (0, react.useRef)(null);
+		const [status, setStatus] = (0, react.useState)("disconnected");
+		const [partialTranscript, setPartialTranscript] = (0, react.useState)("");
+		const [committedTranscripts, setCommittedTranscripts] = (0, react.useState)([]);
+		const [error, setError] = (0, react.useState)(null);
+		(0, react.useEffect)(() => {
+			return () => {
+				connectionRef.current?.close();
+			};
+		}, []);
+		const connect = (0, react.useCallback)(async (runtimeOptions = {}) => {
+			if (connectionRef.current) {
+				console.warn("Already connected");
+				return;
+			}
+			try {
+				setStatus("connecting");
+				setError(null);
+				const token = runtimeOptions.token || defaultToken;
+				const modelId = runtimeOptions.modelId || defaultModelId;
+				if (!token) throw new Error("Token is required");
+				if (!modelId) throw new Error("Model ID is required");
+				const microphone = runtimeOptions.microphone || defaultMicrophone;
+				const audioFormat = runtimeOptions.audioFormat || defaultAudioFormat;
+				const sampleRate = runtimeOptions.sampleRate || defaultSampleRate;
+				let connection;
+				const includeTimestamps = runtimeOptions.includeTimestamps ?? defaultIncludeTimestamps ?? !!(runtimeOptions.onCommittedTranscriptWithTimestamps || onCommittedTranscriptWithTimestamps);
+				if (microphone) connection = _elevenlabs_client.Scribe.connect({
+					token,
+					modelId,
+					baseUri: runtimeOptions.baseUri || defaultBaseUri,
+					commitStrategy: runtimeOptions.commitStrategy || defaultCommitStrategy,
+					vadSilenceThresholdSecs: runtimeOptions.vadSilenceThresholdSecs || defaultVadSilenceThresholdSecs,
+					vadThreshold: runtimeOptions.vadThreshold || defaultVadThreshold,
+					minSpeechDurationMs: runtimeOptions.minSpeechDurationMs || defaultMinSpeechDurationMs,
+					minSilenceDurationMs: runtimeOptions.minSilenceDurationMs || defaultMinSilenceDurationMs,
+					languageCode: runtimeOptions.languageCode || defaultLanguageCode,
+					microphone,
+					includeTimestamps
+				});
+				else if (audioFormat && sampleRate) connection = _elevenlabs_client.Scribe.connect({
+					token,
+					modelId,
+					baseUri: runtimeOptions.baseUri || defaultBaseUri,
+					commitStrategy: runtimeOptions.commitStrategy || defaultCommitStrategy,
+					vadSilenceThresholdSecs: runtimeOptions.vadSilenceThresholdSecs || defaultVadSilenceThresholdSecs,
+					vadThreshold: runtimeOptions.vadThreshold || defaultVadThreshold,
+					minSpeechDurationMs: runtimeOptions.minSpeechDurationMs || defaultMinSpeechDurationMs,
+					minSilenceDurationMs: runtimeOptions.minSilenceDurationMs || defaultMinSilenceDurationMs,
+					languageCode: runtimeOptions.languageCode || defaultLanguageCode,
+					includeTimestamps,
+					audioFormat,
+					sampleRate
+				});
+				else throw new Error("Either microphone options or (audioFormat + sampleRate) must be provided");
+				connectionRef.current = connection;
+				connection.on(_elevenlabs_client.RealtimeEvents.SESSION_STARTED, () => {
+					setStatus("connected");
+					onSessionStarted?.();
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
+					const message = data;
+					setPartialTranscript(message.text);
+					setStatus("transcribing");
+					onPartialTranscript?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
+					const message = data;
+					const segment = {
+						id: `${Date.now()}-${Math.random()}`,
+						text: message.text,
+						timestamp: Date.now(),
+						isFinal: true
+					};
+					setCommittedTranscripts((prev) => [...prev, segment]);
+					setPartialTranscript("");
+					onCommittedTranscript?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS, (data) => {
+					const message = data;
+					const segment = {
+						id: `${Date.now()}-${Math.random()}`,
+						text: message.text,
+						timestamp: Date.now(),
+						isFinal: true,
+						words: message.words
+					};
+					setCommittedTranscripts((prev) => [...prev, segment]);
+					setPartialTranscript("");
+					onCommittedTranscriptWithTimestamps?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.ERROR, (err) => {
+					const message = err;
+					setError(message.error);
+					setStatus("error");
+					onError?.(new Error(message.error));
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.AUTH_ERROR, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onAuthError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.QUOTA_EXCEEDED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onQuotaExceededError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.COMMIT_THROTTLED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onCommitThrottledError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.TRANSCRIBER_ERROR, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onTranscriberError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.UNACCEPTED_TERMS, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onUnacceptedTermsError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.RATE_LIMITED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onRateLimitedError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.INPUT_ERROR, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onInputError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.QUEUE_OVERFLOW, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onQueueOverflowError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.RESOURCE_EXHAUSTED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onResourceExhaustedError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.SESSION_TIME_LIMIT_EXCEEDED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onSessionTimeLimitExceededError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.CHUNK_SIZE_EXCEEDED, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onChunkSizeExceededError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.INSUFFICIENT_AUDIO_ACTIVITY, (data) => {
+					const message = data;
+					setError(message.error);
+					setStatus("error");
+					onInsufficientAudioActivityError?.(message);
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.OPEN, () => {
+					onConnect?.();
+				});
+				connection.on(_elevenlabs_client.RealtimeEvents.CLOSE, () => {
+					setStatus("disconnected");
+					connectionRef.current = null;
+					onDisconnect?.();
+				});
+			} catch (err) {
+				setError(err instanceof Error ? err.message : "Failed to connect");
+				setStatus("error");
+				throw err;
+			}
+		}, [
+			defaultToken,
+			defaultModelId,
+			defaultBaseUri,
+			defaultCommitStrategy,
+			defaultVadSilenceThresholdSecs,
+			defaultVadThreshold,
+			defaultMinSpeechDurationMs,
+			defaultMinSilenceDurationMs,
+			defaultLanguageCode,
+			defaultMicrophone,
+			defaultAudioFormat,
+			defaultSampleRate,
+			defaultIncludeTimestamps,
+			onSessionStarted,
+			onPartialTranscript,
+			onCommittedTranscript,
+			onCommittedTranscriptWithTimestamps,
+			onError,
+			onAuthError,
+			onQuotaExceededError,
+			onCommitThrottledError,
+			onTranscriberError,
+			onUnacceptedTermsError,
+			onRateLimitedError,
+			onInputError,
+			onQueueOverflowError,
+			onResourceExhaustedError,
+			onSessionTimeLimitExceededError,
+			onChunkSizeExceededError,
+			onInsufficientAudioActivityError,
+			onConnect,
+			onDisconnect
+		]);
+		const disconnect = (0, react.useCallback)(() => {
+			connectionRef.current?.close();
+			connectionRef.current = null;
+			setStatus("disconnected");
+		}, []);
+		const sendAudio = (0, react.useCallback)((audioBase64, options) => {
+			if (!connectionRef.current) throw new Error("Not connected to Scribe");
+			connectionRef.current.send({
+				audioBase64,
+				...options
+			});
+		}, []);
+		const commit = (0, react.useCallback)(() => {
+			if (!connectionRef.current) throw new Error("Not connected to Scribe");
+			connectionRef.current.commit();
+		}, []);
+		const clearTranscripts = (0, react.useCallback)(() => {
+			setCommittedTranscripts([]);
+			setPartialTranscript("");
+		}, []);
+		const getConnection = (0, react.useCallback)(() => {
+			return connectionRef.current;
+		}, []);
+		(0, react.useEffect)(() => {
+			if (autoConnect) connect();
+		}, [autoConnect, connect]);
+		return {
+			status,
+			isConnected: status === "connected" || status === "transcribing",
+			isTranscribing: status === "transcribing",
+			partialTranscript,
+			committedTranscripts,
+			error,
+			connect,
+			disconnect,
+			sendAudio,
+			commit,
+			clearTranscripts,
+			getConnection
+		};
+	}
+	//#endregion
+	//#region src/conversation/ConversationContext.tsx
+	const ConversationContext = (0, react.createContext)(null);
+	/**
+	* Returns the raw `Conversation` instance (or `null` if no session is active).
+	* This is a public escape hatch for advanced use cases that need direct access
+	* to the underlying `@elevenlabs/client` Conversation object.
+	*
+	* Can be used outside a `ConversationProvider` — returns `null` in that case.
+	*/
+	function useRawConversation() {
+		return (0, react.useContext)(ConversationContext)?.conversation ?? null;
+	}
+	/**
+	* Returns a stable ref to the active `Conversation` instance.
+	* The ref's `.current` is `null` when no session is active, and updates
+	* without causing re-renders — ideal for use inside callbacks and sub-providers.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useRawConversationRef() {
+		const ctx = (0, react.useContext)(ConversationContext);
+		if (!ctx) throw new Error("useRawConversationRef must be used within a ConversationProvider");
+		return ctx.conversationRef;
+	}
+	/**
+	* Registers callback handlers with the nearest `ConversationProvider`.
+	* Uses a ref internally so the latest callback values are always invoked
+	* without re-subscribing on every render.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useRegisterCallbacks(callbacks) {
+		const ctx = (0, react.useContext)(ConversationContext);
+		if (!ctx) throw new Error("useRegisterCallbacks must be used within a ConversationProvider");
+		const { registerCallbacks } = ctx;
+		const callbacksRef = (0, react.useRef)(callbacks);
+		callbacksRef.current = callbacks;
+		const activeKeys = Object.keys(callbacks).filter((key) => callbacks[key] !== void 0).sort();
+		(0, react.useLayoutEffect)(() => {
+			return registerCallbacks(Object.fromEntries(activeKeys.map((key) => [key, (...args) => {
+				const fn = callbacksRef.current[key];
+				if (typeof fn === "function") fn(...args);
+			}])));
+		}, [registerCallbacks, activeKeys.join("|")]);
+	}
+	//#endregion
+	//#region ../../node_modules/.pnpm/react@19.1.0/node_modules/react/cjs/react-jsx-runtime.production.js
+	/**
+	* @license React
+	* react-jsx-runtime.production.js
+	*
+	* Copyright (c) Meta Platforms, Inc. and affiliates.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file in the root directory of this source tree.
+	*/
+	var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+		var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+		function jsxProd(type, config, maybeKey) {
+			var key = null;
+			void 0 !== maybeKey && (key = "" + maybeKey);
+			void 0 !== config.key && (key = "" + config.key);
+			if ("key" in config) {
+				maybeKey = {};
+				for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+			} else maybeKey = config;
+			config = maybeKey.ref;
+			return {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				ref: void 0 !== config ? config : null,
+				props: maybeKey
+			};
+		}
+		exports.jsx = jsxProd;
+	}));
+	//#endregion
+	//#region src/conversation/ConversationControls.tsx
+	var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+		module.exports = require_react_jsx_runtime_production();
+	})))();
+	const ConversationControlsContext = (0, react.createContext)(null);
+	/**
+	* Reads from `ConversationContext` and provides stable action references to
+	* `ConversationControlsContext`. Must be rendered inside a `ConversationProvider`.
+	*/
+	function ConversationControlsProvider({ children }) {
+		const ctx = (0, react.useContext)(ConversationContext);
+		if (!ctx) throw new Error("ConversationControlsProvider must be rendered inside a ConversationProvider");
+		const { conversationRef } = ctx;
+		const getConversation = (0, react.useCallback)(() => {
+			const conversation = conversationRef.current;
+			if (!conversation) throw new Error("No active conversation. Call startSession() first.");
+			return conversation;
+		}, [conversationRef]);
+		const sendUserMessage = (0, react.useCallback)((text) => {
+			getConversation().sendUserMessage(text);
+		}, [getConversation]);
+		const sendContextualUpdate = (0, react.useCallback)((text) => {
+			getConversation().sendContextualUpdate(text);
+		}, [getConversation]);
+		const sendUserActivity = (0, react.useCallback)(() => {
+			getConversation().sendUserActivity();
+		}, [getConversation]);
+		const sendMCPToolApprovalResult = (0, react.useCallback)((toolCallId, isApproved) => {
+			getConversation().sendMCPToolApprovalResult(toolCallId, isApproved);
+		}, [getConversation]);
+		const setVolume = (0, react.useCallback)((options) => {
+			getConversation().setVolume(options);
+		}, [getConversation]);
+		const changeInputDevice = (0, react.useCallback)(async (config) => {
+			const conversation = getConversation();
+			if (conversation instanceof _elevenlabs_client.VoiceConversation) return await conversation.changeInputDevice(config);
+			throw new Error("Device switching is only available for voice conversations");
+		}, [getConversation]);
+		const changeOutputDevice = (0, react.useCallback)(async (config) => {
+			const conversation = getConversation();
+			if (conversation instanceof _elevenlabs_client.VoiceConversation) return await conversation.changeOutputDevice(config);
+			throw new Error("Device switching is only available for voice conversations");
+		}, [getConversation]);
+		const getInputByteFrequencyData = (0, react.useCallback)(() => {
+			return getConversation().getInputByteFrequencyData();
+		}, [getConversation]);
+		const getOutputByteFrequencyData = (0, react.useCallback)(() => {
+			return getConversation().getOutputByteFrequencyData();
+		}, [getConversation]);
+		const getInputVolume = (0, react.useCallback)(() => {
+			return getConversation().getInputVolume();
+		}, [getConversation]);
+		const getOutputVolume = (0, react.useCallback)(() => {
+			return getConversation().getOutputVolume();
+		}, [getConversation]);
+		const getId = (0, react.useCallback)(() => {
+			return getConversation().getId();
+		}, [getConversation]);
+		const value = (0, react.useMemo)(() => ({
+			startSession: ctx.startSession,
+			endSession: ctx.endSession,
+			sendUserMessage,
+			sendContextualUpdate,
+			sendUserActivity,
+			sendMCPToolApprovalResult,
+			setVolume,
+			changeInputDevice,
+			changeOutputDevice,
+			getInputByteFrequencyData,
+			getOutputByteFrequencyData,
+			getInputVolume,
+			getOutputVolume,
+			getId
+		}), [
+			ctx.startSession,
+			ctx.endSession,
+			sendUserMessage,
+			sendContextualUpdate,
+			sendUserActivity,
+			sendMCPToolApprovalResult,
+			setVolume,
+			changeInputDevice,
+			changeOutputDevice,
+			getInputByteFrequencyData,
+			getOutputByteFrequencyData,
+			getInputVolume,
+			getOutputVolume,
+			getId
+		]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationControlsContext.Provider, {
+			value,
+			children
+		});
+	}
+	/**
+	* Returns stable action references for controlling the conversation.
+	* All function references are stable and will never cause re-renders.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversationControls() {
+		const ctx = (0, react.useContext)(ConversationControlsContext);
+		if (!ctx) throw new Error("useConversationControls must be used within a ConversationProvider");
+		return ctx;
+	}
+	//#endregion
+	//#region src/conversation/ConversationStatus.tsx
+	const ConversationStatusContext = (0, react.createContext)(null);
+	/**
+	* Reads from `ConversationContext` and registers `onStatusChange` + `onError`
+	* callbacks. Manages its own `status`/`message` state and provides it through
+	* `ConversationStatusContext`. Must be rendered inside a `ConversationProvider`.
+	*/
+	function ConversationStatusProvider({ children }) {
+		const [status, setStatus] = (0, react.useState)("disconnected");
+		const [message, setMessage] = (0, react.useState)(void 0);
+		useRegisterCallbacks({
+			onStatusChange({ status: newStatus }) {
+				if (newStatus === "disconnecting") return;
+				setStatus(newStatus);
+				setMessage(void 0);
+			},
+			onError(errorMessage) {
+				setStatus("error");
+				setMessage(errorMessage);
+			}
+		});
+		const value = (0, react.useMemo)(() => ({
+			status,
+			message
+		}), [status, message]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationStatusContext.Provider, {
+			value,
+			children
+		});
+	}
+	/**
+	* Returns the current conversation status and any error message.
+	* Re-renders when the connection status or error message changes.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversationStatus() {
+		const ctx = (0, react.useContext)(ConversationStatusContext);
+		if (!ctx) throw new Error("useConversationStatus must be used within a ConversationProvider");
+		return ctx;
+	}
+	//#endregion
+	//#region src/conversation/ConversationInput.tsx
+	const ConversationInputContext = (0, react.createContext)(null);
+	/**
+	* Reads from `ConversationContext` and manages microphone mute state.
+	* `setMuted` calls `conversation.setMicMuted()` and updates local state.
+	* Must be rendered inside a `ConversationProvider`.
+	*/
+	function ConversationInputProvider({ children }) {
+		const conversationRef = useRawConversationRef();
+		const [isMuted, setIsMuted] = (0, react.useState)(false);
+		useRegisterCallbacks({ onDisconnect() {
+			setIsMuted(false);
+		} });
+		const setMuted = (0, react.useCallback)((muted) => {
+			const conversation = conversationRef.current;
+			if (!conversation) throw new Error("No active conversation. Call startSession() first.");
+			conversation.setMicMuted(muted);
+			setIsMuted(muted);
+		}, [conversationRef]);
+		const value = (0, react.useMemo)(() => ({
+			isMuted,
+			setMuted
+		}), [isMuted, setMuted]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationInputContext.Provider, {
+			value,
+			children
+		});
+	}
+	/**
+	* Returns the current microphone mute state and a function to change it.
+	* Re-renders only when the mute state changes.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversationInput() {
+		const ctx = (0, react.useContext)(ConversationInputContext);
+		if (!ctx) throw new Error("useConversationInput must be used within a ConversationProvider");
+		return ctx;
+	}
+	//#endregion
+	//#region src/conversation/ConversationMode.tsx
+	const ConversationModeContext = (0, react.createContext)(null);
+	/**
+	* Reads from `ConversationContext` and registers an `onModeChange` callback.
+	* Manages its own `mode` state and provides it through
+	* `ConversationModeContext`. Must be rendered inside a `ConversationProvider`.
+	*/
+	function ConversationModeProvider({ children }) {
+		const [mode, setMode] = (0, react.useState)("listening");
+		useRegisterCallbacks({
+			onModeChange({ mode: newMode }) {
+				setMode(newMode);
+			},
+			onDisconnect() {
+				setMode("listening");
+			}
+		});
+		const value = (0, react.useMemo)(() => ({
+			mode,
+			isSpeaking: mode === "speaking",
+			isListening: mode === "listening"
+		}), [mode]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationModeContext.Provider, {
+			value,
+			children
+		});
+	}
+	/**
+	* Returns the current conversation mode (speaking/listening) and
+	* convenience booleans. Re-renders only when the mode changes.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversationMode() {
+		const ctx = (0, react.useContext)(ConversationModeContext);
+		if (!ctx) throw new Error("useConversationMode must be used within a ConversationProvider");
+		return ctx;
+	}
+	//#endregion
+	//#region src/conversation/ConversationFeedback.tsx
+	const ConversationFeedbackContext = (0, react.createContext)(null);
+	/**
+	* Reads from `ConversationContext` and registers an `onCanSendFeedbackChange`
+	* callback. Manages its own `canSendFeedback` state and provides it along with
+	* a `sendFeedback` action through `ConversationFeedbackContext`.
+	* Must be rendered inside a `ConversationProvider`.
+	*/
+	function ConversationFeedbackProvider({ children }) {
+		const conversationRef = useRawConversationRef();
+		const [canSendFeedback, setCanSendFeedback] = (0, react.useState)(false);
+		useRegisterCallbacks({
+			onCanSendFeedbackChange({ canSendFeedback: newValue }) {
+				setCanSendFeedback(newValue);
+			},
+			onDisconnect() {
+				setCanSendFeedback(false);
+			}
+		});
+		const sendFeedback = (0, react.useCallback)((like) => {
+			conversationRef.current?.sendFeedback(like);
+		}, [conversationRef]);
+		const value = (0, react.useMemo)(() => ({
+			canSendFeedback,
+			sendFeedback
+		}), [canSendFeedback, sendFeedback]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationFeedbackContext.Provider, {
+			value,
+			children
+		});
+	}
+	/**
+	* Returns the current feedback state and a `sendFeedback` action.
+	* Re-renders only when `canSendFeedback` changes.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversationFeedback() {
+		const ctx = (0, react.useContext)(ConversationFeedbackContext);
+		if (!ctx) throw new Error("useConversationFeedback must be used within a ConversationProvider");
+		return ctx;
+	}
+	//#endregion
+	//#region src/conversation/ConversationClientTools.tsx
+	/**
+	* Creates a fresh clientTools object by merging option-provided tools with
+	* hook-registered tools from the registry. Throws if a hook-registered tool
+	* name conflicts with an option-provided tool.
+	*/
+	function buildClientTools(optionTools, registry) {
+		const clientTools = { ...optionTools };
+		for (const [name, handler] of registry) {
+			if (Object.hasOwn(clientTools, name)) throw new Error(`Client tool "${name}" is already provided via props/options. Remove it from props or do not register it with useConversationClientTool.`);
+			clientTools[name] = handler;
+		}
+		return clientTools;
+	}
+	const ConversationClientToolsContext = (0, react.createContext)(null);
+	function ConversationClientToolsProvider({ children }) {
+		const ctx = (0, react.useContext)(ConversationContext);
+		if (!ctx) throw new Error("ConversationClientToolsProvider must be rendered inside a ConversationProvider");
+		const { clientToolsRegistry, clientToolsRef } = ctx;
+		const registerClientTool = (0, react.useCallback)((name, handler) => {
+			if (clientToolsRegistry.has(name)) throw new Error(`Client tool "${name}" is already registered by another hook. Each tool name must be unique.`);
+			clientToolsRegistry.set(name, handler);
+			clientToolsRef.current[name] = handler;
+			return () => {
+				if (clientToolsRegistry.get(name) === handler) clientToolsRegistry.delete(name);
+				if (clientToolsRef.current[name] === handler) delete clientToolsRef.current[name];
+			};
+		}, [clientToolsRegistry, clientToolsRef]);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationClientToolsContext.Provider, {
+			value: registerClientTool,
+			children
+		});
+	}
+	/**
+	* Registers a named client tool with the nearest `ConversationProvider`.
+	* The tool is available during any active conversation and is automatically
+	* unregistered when the component unmounts.
+	*
+	* The handler always reflects the latest closure value (ref pattern),
+	* so it is safe to reference component state or props without listing
+	* them as dependencies.
+	*
+	* @typeParam TTools - An interface mapping tool names to function signatures.
+	* @typeParam TName  - The specific tool name (inferred from the first argument).
+	* @param name    - The tool name (must match the name configured on the agent).
+	* @param handler - The function invoked when the agent calls this tool.
+	*
+	* @example
+	* ```tsx
+	* type Tools = {
+	*   get_weather: (params: { city: string }) => string;
+	*   set_volume: (params: { level: number }) => void;
+	* };
+	*
+	* useConversationClientTool<Tools>("get_weather", (params) => {
+	*   return `Weather in ${params.city} is sunny.`;
+	* });
+	* ```
+	*/
+	function useConversationClientTool(name, handler) {
+		const registerClientTool = (0, react.useContext)(ConversationClientToolsContext);
+		if (!registerClientTool) throw new Error("useConversationClientTool must be used within a ConversationProvider");
+		const handlerRef = (0, react.useRef)(handler);
+		handlerRef.current = handler;
+		(0, react.useLayoutEffect)(() => {
+			const stableHandler = (parameters) => handlerRef.current(parameters);
+			return registerClientTool(name, stableHandler);
+		}, [registerClientTool, name]);
+	}
+	//#endregion
+	//#region src/conversation/ListenerSet.ts
+	var ListenerSet = class {
+		listeners = /* @__PURE__ */ new Set();
+		add(fn) {
+			this.listeners.add(fn);
+			return () => {
+				this.listeners.delete(fn);
+			};
+		}
+		invoke(...args) {
+			for (const fn of this.listeners) fn(...args);
+		}
+		get size() {
+			return this.listeners.size;
+		}
+	};
+	//#endregion
+	//#region src/conversation/ListenerMap.ts
+	function assertFunction(value, key) {
+		if (typeof value !== "function") throw new Error(`Expected function for key "${key}", got ${typeof value}`);
+	}
+	/**
+	* A map of named listener sets. Each key maps to a `ListenerSet` that can have
+	* multiple listeners registered. Typed through `T` so that `register` and
+	* `compose` preserve per-key callback signatures.
+	*
+	* All keys are pre-initialized in the constructor so `register` can validate
+	* keys. `compose()` only includes keys with at least one registered listener,
+	* preserving callback-presence semantics used by the client as feature guards.
+	* For included keys, composed functions delegate to the live listener set, so
+	* listeners added/removed after `compose()` still take effect. Keys with no
+	* listeners at compose time are omitted entirely; call `compose()` again after
+	* registering listeners to pick up newly populated keys.
+	*/
+	var ListenerMap = class {
+		sets = /* @__PURE__ */ new Map();
+		constructor(keys) {
+			for (const key of keys) this.sets.set(key, new ListenerSet());
+		}
+		/**
+		* Register listeners for one or more keys. Returns a function that removes
+		* all listeners added by this call.
+		*/
+		register(callbacks) {
+			const removers = Object.entries(callbacks).filter(([, fn]) => fn !== void 0).map(([key, fn]) => {
+				assertFunction(fn, key);
+				const set = this.sets.get(key);
+				if (!set) throw new Error(`Unknown callback key "${key}"`);
+				return set.add(fn);
+			});
+			return () => {
+				for (const remove of removers) remove();
+			};
+		}
+		/**
+		* Compose all registered listeners into a single callbacks object. Each
+		* composed function delegates to the live listener set, so listeners
+		* added/removed after this call still take effect.
+		*/
+		compose() {
+			return Object.fromEntries(Array.from(this.sets.entries()).filter(([, set]) => set.size > 0).map(([key, set]) => [key, (...args) => {
+				set.invoke(...args);
+			}]));
+		}
+	};
+	//#endregion
+	//#region src/conversation/useStableCallbacks.ts
+	/**
+	* Wraps user-provided callback props in stable ref-backed functions,
+	* preventing stale closure bugs when the session outlives renders.
+	*
+	* Returns a `Partial<Callbacks>` containing only the keys the caller
+	* actually provided. Function references are stable per key across
+	* renders, but always invoke the latest prop value. The returned object
+	* reference is stable as long as the set of provided keys doesn't change.
+	*/
+	function useStableCallbacks(props) {
+		const callbackRefs = (0, react.useRef)({});
+		for (const key of _elevenlabs_client_internal.CALLBACK_KEYS) callbackRefs.current[key] = props[key];
+		const activeKeys = _elevenlabs_client_internal.CALLBACK_KEYS.filter((key) => props[key] !== void 0);
+		return (0, react.useMemo)(() => Object.fromEntries(activeKeys.map((key) => [key, (...args) => {
+			const fn = callbackRefs.current[key];
+			fn?.(...args);
+		}])), [activeKeys.join("|")]);
+	}
+	//#endregion
+	//#region src/conversation/ConversationProvider.tsx
+	const SUB_PROVIDERS = [
+		ConversationControlsProvider,
+		ConversationStatusProvider,
+		ConversationInputProvider,
+		ConversationModeProvider,
+		ConversationFeedbackProvider,
+		ConversationClientToolsProvider
+	];
+	function ConversationProvider({ children, ...defaultOptions }) {
+		/** The active conversation instance, if any. */
+		const conversationRef = (0, react.useRef)(null);
+		/** In-flight startSession promise, used to prevent duplicate connections. */
+		const lockRef = (0, react.useRef)(null);
+		/** Signals that endSession was called while a connection was still pending. */
+		const shouldEndRef = (0, react.useRef)(false);
+		/** Registry of hook-registered client tools. Survives across sessions. */
+		const [clientToolsRegistry] = (0, react.useState)(() => /* @__PURE__ */ new Map());
+		/** Ref to the live clientTools object currently held by BaseConversation. */
+		const clientToolsRef = (0, react.useRef)({});
+		/** Always holds the latest provider props, avoiding stale closures in callbacks. */
+		const defaultOptionsRef = (0, react.useRef)(defaultOptions);
+		defaultOptionsRef.current = defaultOptions;
+		/** Callback registry for sub-providers (status, mode, feedback, etc.). */
+		const [listenerMap] = (0, react.useState)(() => new ListenerMap(_elevenlabs_client_internal.CALLBACK_KEYS));
+		/** Reactive mirror of conversationRef, triggers re-renders for context consumers. */
+		const [conversation, setConversation] = (0, react.useState)(null);
+		const stableCallbacks = useStableCallbacks(defaultOptions);
+		const registerCallbacks = (0, react.useCallback)((callbacks) => listenerMap.register(callbacks), [listenerMap]);
+		(0, react.useLayoutEffect)(() => {
+			return listenerMap.register({ onDisconnect: () => {
+				conversationRef.current = null;
+				setConversation(null);
+			} });
+		}, [listenerMap]);
+		const startSession = (0, react.useCallback)((options) => {
+			if (conversationRef.current) return;
+			if (lockRef.current) return;
+			shouldEndRef.current = false;
+			const defaults = defaultOptionsRef.current;
+			const resolvedServerLocation = (0, _elevenlabs_client_internal.parseLocation)(options?.serverLocation || defaults?.serverLocation);
+			const origin = (0, _elevenlabs_client_internal.getOriginForLocation)(resolvedServerLocation);
+			const calculatedLivekitUrl = (0, _elevenlabs_client_internal.getLivekitUrlForLocation)(resolvedServerLocation);
+			const defaultConfig = { ...defaults };
+			for (const key of _elevenlabs_client_internal.CALLBACK_KEYS) delete defaultConfig[key];
+			const sessionOptions = (0, _elevenlabs_client_internal.mergeOptions)({ livekitUrl: calculatedLivekitUrl }, defaultConfig, stableCallbacks, listenerMap.compose(), options ?? {}, { origin });
+			const clientTools = buildClientTools(sessionOptions.clientTools, clientToolsRegistry);
+			clientToolsRef.current = clientTools;
+			sessionOptions.clientTools = clientTools;
+			lockRef.current = _elevenlabs_client.Conversation.startSession(sessionOptions);
+			lockRef.current.then((conv) => {
+				if (shouldEndRef.current) {
+					conv.endSession();
+					lockRef.current = null;
+					return;
+				}
+				conversationRef.current = conv;
+				setConversation(conv);
+				lockRef.current = null;
+			}, () => {
+				lockRef.current = null;
+			});
+		}, [
+			stableCallbacks,
+			listenerMap,
+			clientToolsRegistry,
+			clientToolsRef
+		]);
+		const endSession = (0, react.useCallback)(() => {
+			shouldEndRef.current = true;
+			const pendingConnection = lockRef.current;
+			const conv = conversationRef.current;
+			conversationRef.current = null;
+			setConversation(null);
+			if (pendingConnection) pendingConnection.then((c) => c.endSession());
+			else conv?.endSession();
+		}, []);
+		(0, react.useEffect)(() => {
+			return () => {
+				shouldEndRef.current = true;
+				if (lockRef.current) lockRef.current.then((conv) => conv.endSession());
+				else conversationRef.current?.endSession();
+			};
+		}, []);
+		const contextValue = (0, react.useMemo)(() => ({
+			conversation,
+			conversationRef,
+			startSession,
+			endSession,
+			registerCallbacks,
+			clientToolsRegistry,
+			clientToolsRef
+		}), [
+			conversation,
+			conversationRef,
+			startSession,
+			endSession,
+			registerCallbacks,
+			clientToolsRegistry,
+			clientToolsRef
+		]);
+		const wrappedChildren = SUB_PROVIDERS.reduceRight((nested, Provider) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider, { children: nested }), children);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConversationContext.Provider, {
+			value: contextValue,
+			children: wrappedChildren
+		});
+	}
+	//#endregion
+	//#region src/conversation/useConversation.ts
+	/**
+	* Convenience hook that combines all granular conversation hooks into a single
+	* return value. Less performant than using individual hooks because any state
+	* change in any sub-context triggers a re-render of the consuming component.
+	*
+	* Accepts optional `micMuted`, `volume`, session config, and callback props.
+	* Session config and callbacks passed here are used as defaults when calling
+	* `startSession()` without arguments. Callbacks are also registered with the
+	* provider so they stay up-to-date across re-renders.
+	*
+	* Must be used within a `ConversationProvider`.
+	*/
+	function useConversation(props = {}) {
+		const { micMuted, volume, ...hookOptions } = props;
+		useRegisterCallbacks(useStableCallbacks(hookOptions));
+		const hookOptionsRef = (0, react.useRef)(hookOptions);
+		hookOptionsRef.current = hookOptions;
+		const controls = useConversationControls();
+		const { status, message } = useConversationStatus();
+		const { isMuted, setMuted } = useConversationInput();
+		const { mode, isSpeaking, isListening } = useConversationMode();
+		const { canSendFeedback, sendFeedback } = useConversationFeedback();
+		const startSession = (0, react.useCallback)((options) => {
+			const sessionConfig = { ...hookOptionsRef.current };
+			for (const key of _elevenlabs_client_internal.CALLBACK_KEYS) delete sessionConfig[key];
+			controls.startSession({
+				...sessionConfig,
+				...options
+			});
+		}, [controls, hookOptionsRef]);
+		const conversation = useRawConversation();
+		(0, react.useEffect)(() => {
+			if (micMuted !== void 0 && conversation) setMuted(micMuted);
+		}, [
+			micMuted,
+			conversation,
+			setMuted
+		]);
+		(0, react.useEffect)(() => {
+			if (volume !== void 0 && conversation) conversation.setVolume({ volume });
+		}, [volume, conversation]);
+		return {
+			...controls,
+			startSession,
+			status,
+			message,
+			isMuted: micMuted ?? isMuted,
+			setMuted,
+			mode,
+			isSpeaking,
+			isListening,
+			canSendFeedback,
+			sendFeedback
+		};
+	}
+	//#endregion
+	//#region src/index.ts
+	(0, _elevenlabs_client_internal.setSourceInfo)({
+		name: "react_sdk",
+		version: PACKAGE_VERSION
+	});
+	//#endregion
+	Object.defineProperty(exports, "AudioFormat", {
+		enumerable: true,
+		get: function() {
+			return _elevenlabs_client.AudioFormat;
+		}
+	});
+	Object.defineProperty(exports, "CommitStrategy", {
+		enumerable: true,
+		get: function() {
+			return _elevenlabs_client.CommitStrategy;
+		}
+	});
+	exports.ConversationProvider = ConversationProvider;
+	Object.defineProperty(exports, "RealtimeEvents", {
+		enumerable: true,
+		get: function() {
+			return _elevenlabs_client.RealtimeEvents;
+		}
+	});
+	exports.useConversation = useConversation;
+	exports.useConversationClientTool = useConversationClientTool;
+	exports.useConversationControls = useConversationControls;
+	exports.useConversationFeedback = useConversationFeedback;
+	exports.useConversationInput = useConversationInput;
+	exports.useConversationMode = useConversationMode;
+	exports.useConversationStatus = useConversationStatus;
+	exports.useRawConversation = useRawConversation;
+	exports.useScribe = useScribe;
+	Object.keys(_elevenlabs_client).forEach(function(k) {
+		if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+			enumerable: true,
+			get: function() {
+				return _elevenlabs_client[k];
+			}
+		});
+	});
+	return exports;
+})({}, _elevenlabs_client_internal, _elevenlabs_client, react);
+
+//# sourceMappingURL=lib.iife.js.map