realtime-avatar 0.24.1 → 0.26.0

package/dist/react-native.js

@@ -1,9 +1,9 @@
 import { AudioSession, LiveKitRoom, VideoTrack } from '@livekit/react-native';
 export { AudioSession, VideoTrack, registerGlobals } from '@livekit/react-native';
 import { useState, useRef, useEffect, useCallback, createElement, useMemo } from 'react';
-import { useLocalParticipant, useConnectionState, useTranscriptions, useMaybeRoomContext, useVoiceAssistant, isTrackReference, useRoomContext, useChat } from '@livekit/components-react';
+import { useLocalParticipant, useConnectionState, useTranscriptions, useMaybeRoomContext, useVoiceAssistant, isTrackReference, useRoomContext, useChat, useAudioPlayback } from '@livekit/components-react';
 export { useChat, useConnectionState, useLocalParticipant, useRoomContext, useTrackToggle, useTranscriptions, useVoiceAssistant } from '@livekit/components-react';
-import { ConnectionState, isRemoteTrack, VideoQuality, ConnectionQuality, RoomEvent, TrackEvent, Track, ConnectionError, ConnectionErrorReason, DisconnectReason, createLocalVideoTrack, Room } from 'livekit-client';
+import { ConnectionState, isRemoteTrack, VideoQuality, ConnectionQuality, RoomEvent, TrackEvent, Track, ConnectionError, ConnectionErrorReason, ParticipantEvent, DisconnectReason, createLocalVideoTrack, Room } from 'livekit-client';
 export { DisconnectReason, Room, RoomEvent, Track } from 'livekit-client';
 import { Platform, StyleSheet, Animated, Image, View, Text } from 'react-native';
 import { z } from 'zod';
@@ -414,7 +414,13 @@ function normalizeError(input, overrides) {
   };
 }
 
+// ../http-client/src/errors.ts
+function isRequestId(value) {
+  return typeof value === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value);
+}
+
 // ../client/src/errors.ts
+var TIMEOUT_CODE = "upstream_timeout";
 var RealtimeAvatarApiError = class _RealtimeAvatarApiError extends Error {
   constructor(message, status, body, response, metadata = {}) {
     super(message);
@@ -426,6 +432,7 @@ var RealtimeAvatarApiError = class _RealtimeAvatarApiError extends Error {
     this.retryable = metadata.retryable;
     this.billingUrl = metadata.billingUrl;
     this.rawMessage = metadata.rawMessage ?? null;
+    this.requestId = metadata.requestId;
   }
   status;
   body;
@@ -435,6 +442,8 @@ var RealtimeAvatarApiError = class _RealtimeAvatarApiError extends Error {
   billingUrl;
   /** Debug detail returned by the API. Do not render directly in user-facing UI. */
   rawMessage;
+  /** The platform's correlation ID for this attempt. Quote it to support. */
+  requestId;
   get isBillingRequired() {
     return this.status === 402 || this.code === "insufficient_credits" || this.code === "spend_limit_exceeded";
   }
@@ -443,14 +452,31 @@ var RealtimeAvatarApiError = class _RealtimeAvatarApiError extends Error {
     const body = contentType.includes("application/json") ? await response.clone().json().catch(() => null) : await response.clone().text().catch(() => "");
     const rawMessage = (extractErrorMessage(body) ?? response.statusText) || null;
     const metadata = extractErrorMetadata(body, response.status, rawMessage);
+    const bodyRequestId = readRecord(body)?.requestId;
+    const headerRequestId = response.headers.get("x-request-id");
     return new _RealtimeAvatarApiError(
       metadata.message,
       response.status,
       body,
       response,
-      metadata
+      {
+        ...metadata,
+        requestId: isRequestId(bodyRequestId) ? bodyRequestId : isRequestId(headerRequestId) ? headerRequestId : void 0
+      }
     );
   }
+  /**
+   * A request that got no answer before its deadline. The status is the one the vocabulary pairs
+   * with the code, so `normalizeRealtimeAvatarError` reads it back as the same failure.
+   */
+  static timeout(timeoutMs) {
+    const { message, retryable, statuses: [status] } = ERROR_SEMANTICS[TIMEOUT_CODE];
+    return new _RealtimeAvatarApiError(message, status, null, null, {
+      code: TIMEOUT_CODE,
+      retryable,
+      rawMessage: `No response within ${timeoutMs}ms.`
+    });
+  }
 };
 var RealtimeAvatarCapacityError = class extends Error {
   constructor(message, busy) {
@@ -672,6 +698,11 @@ function useLiveKitAvatarGrant(input) {
   });
   const stateRef = useRef(state);
   stateRef.current = state;
+  const wantedRef = useRef(active);
+  wantedRef.current = active;
+  useEffect(() => () => {
+    wantedRef.current = false;
+  }, []);
   const [tabVisible, setTabVisible] = useState(
     () => typeof document === "undefined" || document.visibilityState === "visible"
   );
@@ -712,6 +743,8 @@ function useLiveKitAvatarGrant(input) {
         if (cancelled) {
           if (result.status !== "busy") {
             void client.releaseLiveKitSession(result.grant.session_id, "superseded");
+          } else if (!wantedRef.current && result.busy.queue_ticket_id) {
+            void client.releaseLiveKitQueueTicket(result.busy.queue_ticket_id, "unmount");
           }
           return;
         }
@@ -795,6 +828,9 @@ function sameCapacityState(a, b) {
       return true;
   }
 }
+function publishesMicrophoneByDefault(grant) {
+  return grant?.stt_mode === "server";
+}
 var capacityErrorFromBusy = (busy) => {
   return new RealtimeAvatarCapacityError(busy.message, busy);
 };
@@ -2120,6 +2156,169 @@ function createConnectionHistoryCollector(input) {
   return { enqueue, flush, dispose };
 }
 
+// ../browser/src/microphone.ts
+var HINTS = {
+  "insecure-origin": "The browser only exposes microphones on a secure origin. Serve the page over https, or open it on http://localhost \u2014 a LAN address like http://192.168.1.5 will not do.",
+  "no-answer": "The permission prompt is probably still open, or was dismissed without an answer. Look for it in the address bar, answer it, and try again.",
+  "denied-by-browser": "This site is blocked from using the microphone. Click the icon at the left of the address bar, set Microphone to Allow, and reload.",
+  "denied-by-os": "The operating system is blocking the browser itself, so no site can record. On macOS: System Settings > Privacy & Security > Microphone, enable your browser, then RESTART it \u2014 the change does not apply to a running browser.",
+  "no-device": "No microphone is available. Connect one, and if you are on Bluetooth headphones check they are in a mode that has a microphone.",
+  "device-in-use": "Another application or browser tab is holding the microphone. Close it \u2014 including any call from this page you did not hang up \u2014 and try again.",
+  "device-lost": "The microphone stopped during the call: it was unplugged, or access to it was turned off. Reconnect it or allow access again, then turn the microphone back on.",
+  unknown: "Try again, and if it persists include the message above in your report."
+};
+function isOperatingSystemDenial(message) {
+  return /\bby system\b|system permission/i.test(message);
+}
+function classify(error) {
+  if (error instanceof TypeError && /mediaDevices|undefined/i.test(error.message)) {
+    return { reason: "insecure-origin", message: error.message };
+  }
+  const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+  const message = typeof error === "object" && error !== null && "message" in error && error.message ? String(error.message) : String(error);
+  switch (name) {
+    case "NotAllowedError":
+    case "PermissionDeniedError":
+      return {
+        reason: isOperatingSystemDenial(message) ? "denied-by-os" : "denied-by-browser",
+        message
+      };
+    case "NotFoundError":
+    case "DevicesNotFoundError":
+    case "OverconstrainedError":
+    case "ConstraintNotSatisfiedError":
+      return { reason: "no-device", message };
+    case "NotReadableError":
+    case "TrackStartError":
+    case "AbortError":
+      return { reason: "device-in-use", message };
+    case "SecurityError":
+      return { reason: "insecure-origin", message };
+    default:
+      return { reason: "unknown", message };
+  }
+}
+function describeMicrophoneFailure(error) {
+  const { reason, message } = classify(error);
+  return { reason, message, hint: HINTS[reason] };
+}
+function microphoneLost(message) {
+  return { reason: "device-lost", message, hint: HINTS["device-lost"] };
+}
+
+// ../client/src/react/call-media.ts
+var DEVICE_LOST_MESSAGE = "The microphone track ended during the call.";
+function callMicrophoneFrom(facts, intent) {
+  if (!facts.wanted) return { status: "off" };
+  const { publication } = facts;
+  if (publication) {
+    if (publication.ended) {
+      return publication.muted ? { status: "unavailable", ...microphoneLost(DEVICE_LOST_MESSAGE) } : { status: "pending" };
+    }
+    return publication.muted ? { status: "muted" } : { status: "on" };
+  }
+  if (intent.muted) return { status: "muted" };
+  if (facts.enabling) return { status: "pending" };
+  const error = facts.deviceError;
+  if (error) {
+    const problem = describeMicrophoneFailure(error);
+    const blocked = problem.reason === "denied-by-browser" || problem.reason === "denied-by-os" || problem.reason === "insecure-origin";
+    return blocked ? { status: "blocked", ...problem } : { status: "unavailable", ...problem };
+  }
+  return facts.connected ? { status: "pending" } : { status: "off" };
+}
+function microphoneFacts(room, wanted, connected, enabling, staleError) {
+  const publication = room.localParticipant.getTrackPublication(Track.Source.Microphone);
+  const track = publication?.track;
+  return {
+    wanted,
+    connected,
+    enabling,
+    publication: track ? { muted: publication.isMuted, ended: track.mediaStreamTrack?.readyState === "ended" } : null,
+    deviceError: room.localParticipant.lastMicrophoneError !== staleError && room.localParticipant.lastMicrophoneError || null
+  };
+}
+function useCallMedia(room, options) {
+  const { setMicrophoneFacts, setAudioPlayback, registerMediaControls, microphoneWanted, connectionState, callKey } = options;
+  const connected = connectionState === ConnectionState.Connected;
+  const scope = useMemo(
+    () => ({ room, callKey, stale: room.localParticipant.lastMicrophoneError }),
+    [room, callKey]
+  );
+  const [enabling, setEnabling] = useState(false);
+  const [version, setVersion] = useState(0);
+  const sinksRef = useRef({ setMicrophoneFacts, setAudioPlayback });
+  sinksRef.current = { setMicrophoneFacts, setAudioPlayback };
+  useEffect(() => {
+    if (!setMicrophoneFacts) return;
+    const bump = () => setVersion((value) => value + 1);
+    const participant = room.localParticipant;
+    let watched = null;
+    const watchTrack = () => {
+      watched?.off();
+      const track = participant.getTrackPublication(Track.Source.Microphone)?.track;
+      if (!track) {
+        watched = null;
+        return;
+      }
+      track.on(TrackEvent.Ended, bump).on(TrackEvent.Restarted, bump).on(TrackEvent.Muted, bump).on(TrackEvent.Unmuted, bump);
+      watched = { off: () => {
+        track.off(TrackEvent.Ended, bump).off(TrackEvent.Restarted, bump).off(TrackEvent.Muted, bump).off(TrackEvent.Unmuted, bump);
+      } };
+    };
+    const onPublications = () => {
+      watchTrack();
+      bump();
+    };
+    room.on(RoomEvent.MediaDevicesError, bump).on(RoomEvent.LocalTrackPublished, onPublications).on(RoomEvent.LocalTrackUnpublished, onPublications);
+    participant.on(ParticipantEvent.TrackMuted, bump).on(ParticipantEvent.TrackUnmuted, bump);
+    watchTrack();
+    return () => {
+      watched?.off();
+      room.off(RoomEvent.MediaDevicesError, bump).off(RoomEvent.LocalTrackPublished, onPublications).off(RoomEvent.LocalTrackUnpublished, onPublications);
+      participant.off(ParticipantEvent.TrackMuted, bump).off(ParticipantEvent.TrackUnmuted, bump);
+    };
+  }, [room, setMicrophoneFacts]);
+  useEffect(() => {
+    sinksRef.current.setMicrophoneFacts?.(microphoneFacts(room, microphoneWanted, connected, enabling, scope.stale));
+  }, [room, microphoneWanted, connected, enabling, version, scope]);
+  const { canPlayAudio } = useAudioPlayback(room);
+  useEffect(() => {
+    sinksRef.current.setAudioPlayback?.(!canPlayAudio ? "blocked" : connected ? "allowed" : "unknown");
+  }, [canPlayAudio, connected]);
+  const unlockTriedRef = useRef(null);
+  const connecting = connectionState === ConnectionState.Connecting || connected;
+  useEffect(() => {
+    if (!setAudioPlayback || !connecting || unlockTriedRef.current === room) return;
+    unlockTriedRef.current = room;
+    void room.startAudio().catch(() => void 0);
+  }, [room, setAudioPlayback, connecting]);
+  const controls = useMemo(() => ({
+    startAudio: async () => {
+      try {
+        await room.startAudio();
+      } catch {
+      }
+      return room.canPlaybackAudio;
+    },
+    setMicrophoneEnabled: async (enabled) => {
+      if (enabled) setEnabling(true);
+      try {
+        await room.localParticipant.setMicrophoneEnabled(enabled);
+      } catch {
+      } finally {
+        if (enabled) setEnabling(false);
+        setVersion((value) => value + 1);
+      }
+    }
+  }), [room]);
+  useEffect(() => {
+    if (!registerMediaControls) return;
+    registerMediaControls(controls);
+    return () => registerMediaControls(null);
+  }, [controls, registerMediaControls]);
+}
+
 // ../client/src/react/session-lifecycle.ts
 function phaseForReason(reason) {
   switch (reason) {
@@ -2280,10 +2479,13 @@ function useSessionLifecycle(input) {
   const reconnectPolicyRef = useRef(reconnectPolicy);
   reconnectPolicyRef.current = reconnectPolicy;
   const connectWatchdogMs = typeof connectWatchdogSeconds === "number" && Number.isFinite(connectWatchdogSeconds) ? Math.max(0, Math.floor(connectWatchdogSeconds)) * 1e3 : DEFAULT_CONNECT_WATCHDOG_SECONDS * 1e3;
+  const [userEnded, setUserEnded] = useState(false);
+  const userEndedRef = useRef(false);
+  const phaseRef = useRef({ kind: "idle" });
   const grantState = useLiveKitAvatarGrant({
     client,
     session,
-    active,
+    active: active && !userEnded,
     autoRetryBusy,
     requestOptions
   });
@@ -2300,6 +2502,8 @@ function useSessionLifecycle(input) {
   refreshRef.current = grantState.refresh;
   const releaseRef = useRef(grantState.release);
   releaseRef.current = grantState.release;
+  const clearRef = useRef(grantState.clear);
+  clearRef.current = grantState.clear;
   const capacityRef = useRef(capacity);
   capacityRef.current = capacity;
   const refreshBaselineCapacityRef = useRef(null);
@@ -2326,13 +2530,16 @@ function useSessionLifecycle(input) {
     refreshBaselineCapacityRef.current = null;
     attemptRef.current = 0;
     setAttempt(0);
-    setRecovery({ kind: "connected" });
+    setRecovery(userEndedRef.current ? { kind: "ended", reason: "user" } : { kind: "connected" });
     setConnected(false);
     setAgentPresentState(false);
     lastActivityRef.current = Date.now();
   }, [clearTimer]);
   useEffect(() => {
-    if (!active) reset();
+    if (active) return;
+    userEndedRef.current = false;
+    setUserEnded(false);
+    reset();
   }, [active, reset]);
   const markActivity = useCallback(() => {
     lastActivityRef.current = Date.now();
@@ -2363,6 +2570,7 @@ function useSessionLifecycle(input) {
     leaveRoomRef.current?.();
   }, [clearTimer]);
   const onConnected = useCallback(() => {
+    if (userEndedRef.current) return;
     clearTimer();
     connectedRef.current = true;
     manualReconnectPendingRef.current = false;
@@ -2375,7 +2583,7 @@ function useSessionLifecycle(input) {
   }, [clearTimer]);
   const onDisconnected = useCallback(
     (reason) => {
-      if (!active) return;
+      if (!active || userEndedRef.current) return;
       const action = disconnectAction(reason, connectedRef.current);
       if (action === "noop") return;
       if (action === "reset") {
@@ -2400,7 +2608,7 @@ function useSessionLifecycle(input) {
   );
   const onConnectionError = useCallback(
     (error) => {
-      if (!active || !isRecoverableConnectionError(error)) return;
+      if (!active || userEndedRef.current || !isRecoverableConnectionError(error)) return;
       connectedRef.current = false;
       setConnected(false);
       setAgentPresentState(false);
@@ -2413,6 +2621,9 @@ function useSessionLifecycle(input) {
     },
     [active]
   );
+  useEffect(() => {
+    if (capacity.kind === "error" && recovery.kind === "connected") manualReconnectPendingRef.current = false;
+  }, [capacity, recovery]);
   useEffect(() => {
     if (recovery.kind !== "refreshing" || capacity.kind !== "error") return;
     const baseline = refreshBaselineCapacityRef.current;
@@ -2422,7 +2633,7 @@ function useSessionLifecycle(input) {
   }, [capacity, recovery]);
   const onConnectionStateChange = useCallback(
     (state) => {
-      if (!active) return;
+      if (!active || userEndedRef.current) return;
       if (state === "connected") {
         onConnected();
         return;
@@ -2470,8 +2681,30 @@ function useSessionLifecycle(input) {
     }, step2.delayMs);
     return clearTimer;
   }, [recovery.kind, active, attempt, clearTimer]);
+  const end = useCallback(() => {
+    if (!active || userEndedRef.current || phaseRef.current.kind === "ended") return;
+    userEndedRef.current = true;
+    clearTimer();
+    connectedRef.current = false;
+    manualReconnectPendingRef.current = false;
+    refreshBaselineCapacityRef.current = null;
+    setUserEnded(true);
+    setConnected(false);
+    setAgentPresentState(false);
+    setRecovery({ kind: "ended", reason: "user" });
+    clearRef.current();
+    leaveRoomRef.current?.();
+  }, [active, clearTimer]);
   const reconnect = useCallback(() => {
-    if (!active || manualReconnectPendingRef.current || recovery.kind === "in-place-reconnecting") return;
+    if (!active) return;
+    if (userEndedRef.current) {
+      userEndedRef.current = false;
+      setUserEnded(false);
+      reset();
+      manualReconnectPendingRef.current = true;
+      return;
+    }
+    if (manualReconnectPendingRef.current || recovery.kind === "in-place-reconnecting") return;
     manualReconnectPendingRef.current = true;
     clearTimer();
     attemptRef.current = 0;
@@ -2480,7 +2713,7 @@ function useSessionLifecycle(input) {
     releaseRef.current("superseded");
     setRecovery({ kind: "refreshing", attempt: 0 });
     refreshRef.current();
-  }, [active, clearTimer, recovery.kind]);
+  }, [active, clearTimer, recovery.kind, reset]);
   const endIdleRef = useRef(endIdle);
   endIdleRef.current = endIdle;
   useEffect(() => {
@@ -2512,6 +2745,7 @@ function useSessionLifecycle(input) {
     () => lifecyclePhaseFrom({ capacity, recovery, idle, connected, agentPresent }),
     [capacity, recovery, idle, connected, agentPresent]
   );
+  phaseRef.current = phase;
   const onBehaviorChangeRef = useRef(onBehaviorChange);
   onBehaviorChangeRef.current = onBehaviorChange;
   const lastBehaviorRef = useRef(null);
@@ -2537,6 +2771,7 @@ function useSessionLifecycle(input) {
       stayConnected,
       markActivity,
       reconnect,
+      end,
       onConnected,
       onDisconnected,
       onConnectionError,
@@ -2555,6 +2790,7 @@ function useSessionLifecycle(input) {
       stayConnected,
       markActivity,
       reconnect,
+      end,
       onConnected,
       onDisconnected,
       onConnectionError,
@@ -2569,7 +2805,8 @@ function useSessionLifecycle(input) {
 function SessionLifecycleRoomBridge({
   lifecycle,
   onConnectionDetailsChange,
-  onMediaModeChange
+  onMediaModeChange,
+  microphone
 }) {
   const {
     onConnectionStateChange,
@@ -2580,12 +2817,23 @@ function SessionLifecycleRoomBridge({
     registerDataPublisher,
     registerTurnSender,
     setTurnState,
-    setMedia
+    setMedia,
+    setMicrophoneFacts,
+    setAudioPlayback,
+    registerMediaControls
   } = lifecycle;
   const connectionState = useConnectionState();
   const assistant = useVoiceAssistant();
   const transcriptions = useTranscriptions();
   const room = useRoomContext();
+  useCallMedia(room, {
+    setMicrophoneFacts,
+    setAudioPlayback,
+    registerMediaControls,
+    microphoneWanted: microphone ?? publishesMicrophoneByDefault(lifecycle.grant),
+    connectionState,
+    callKey: lifecycle.grant?.session_id
+  });
   const mediaModeCallbackRef = useRef(onMediaModeChange);
   mediaModeCallbackRef.current = onMediaModeChange;
   const mediaModeEnabled = onMediaModeChange !== void 0 && lifecycle.grant !== null;
@@ -2859,6 +3107,8 @@ function resolveEndReason(workerLabel, innerReason) {
       return "idle";
     case "error":
       return "failed";
+    case "user":
+      return "user_ended";
     default:
       return "disconnected";
   }
@@ -2914,6 +3164,16 @@ function useRealtimeSession(input) {
   const [turn, setTurn] = useState("quiet");
   const [media, setMediaState] = useState({ video: "connecting", audio: "silent" });
   const [behavior, setBehavior] = useState(null);
+  const [microphoneFacts2, setMicrophoneFactsState] = useState({
+    wanted: false,
+    connected: false,
+    enabling: false,
+    publication: null,
+    deviceError: null
+  });
+  const [microphoneMuted, setMicrophoneMuted] = useState(false);
+  const [audioPlayback, setAudioPlaybackState] = useState("unknown");
+  const mediaControlsRef = useRef(null);
   const lastBehaviorRef = useRef(null);
   const lastLabeledEndReasonRef = useRef(null);
   const pendingClipsRef = useRef(/* @__PURE__ */ new Map());
@@ -3020,6 +3280,31 @@ function useRealtimeSession(input) {
   const setMedia = useCallback((next) => {
     setMediaState((prev) => prev.video === next.video && prev.audio === next.audio ? prev : next);
   }, []);
+  const microphoneFactsRef = useRef(microphoneFacts2);
+  microphoneFactsRef.current = microphoneFacts2;
+  const setMicrophoneFacts = useCallback((facts) => setMicrophoneFactsState(facts), []);
+  const setAudioPlayback = useCallback((playback) => setAudioPlaybackState(playback), []);
+  const registerMediaControls = useCallback((controls) => {
+    mediaControlsRef.current = controls;
+  }, []);
+  const startAudio = useCallback(async () => {
+    const controls = mediaControlsRef.current;
+    return controls ? controls.startAudio() : false;
+  }, []);
+  const callEnded = lifecycle.phase.kind === "ended";
+  const callEndedRef = useRef(callEnded);
+  callEndedRef.current = callEnded;
+  const setMicrophoneEnabled = useCallback(async (enabled) => {
+    if (callEndedRef.current) return;
+    setMicrophoneMuted(!enabled);
+    if (!microphoneFactsRef.current.connected) return;
+    await mediaControlsRef.current?.setMicrophoneEnabled(enabled);
+  }, []);
+  const microphone = useMemo(
+    () => callEnded ? { status: "off" } : callMicrophoneFrom(microphoneFacts2, { muted: microphoneMuted }),
+    [callEnded, microphoneFacts2, microphoneMuted]
+  );
+  const callAudioPlayback = callEnded ? "unknown" : audioPlayback;
   useEffect(() => {
     if (phaseKind === "idle" || phaseKind === "ended") return;
     const timer = window.setInterval(() => {
@@ -3164,11 +3449,23 @@ function useRealtimeSession(input) {
     void sendResolvedTurn(last.text, last.attributes, last.id).catch(() => void 0);
   }, [sendResolvedTurn]);
   const end = useCallback((reason) => {
+    if (phaseKind === "ended") return;
     if (reason) lastLabeledEndReasonRef.current = reason;
     lastTurnRef.current = null;
     requestGracefulClose();
-    lifecycle.reset();
-  }, [lifecycle, requestGracefulClose]);
+    lifecycle.end();
+  }, [lifecycle, phaseKind, requestGracefulClose]);
+  const active = inner.active ?? true;
+  useEffect(() => {
+    if (active) return;
+    lastLabeledEndReasonRef.current = null;
+    setMicrophoneMuted(false);
+  }, [active]);
+  const innerReconnect = lifecycle.reconnect;
+  const reconnect = useCallback(() => {
+    if (phaseKind === "ended") lastLabeledEndReasonRef.current = null;
+    innerReconnect();
+  }, [innerReconnect, phaseKind]);
   const performAction = useCallback(
     (actionId, opts) => {
       const requestId = newTurnId();
@@ -3214,6 +3511,7 @@ function useRealtimeSession(input) {
     approachingFiredRef.current = false;
     creditsLowFiredRef.current = false;
     lastTurnRef.current = null;
+    setMicrophoneMuted(false);
     lifecycle.reset();
   }, [lifecycle]);
   return useMemo(
@@ -3227,6 +3525,12 @@ function useRealtimeSession(input) {
       endsAt,
       graceWindow,
       media,
+      microphone,
+      audioPlayback: callAudioPlayback,
+      startAudio,
+      setMicrophoneEnabled,
+      microphoneMuted,
+      reconnect,
       lifecycle,
       sendClosingTurn,
       requestGracefulClose,
@@ -3242,6 +3546,9 @@ function useRealtimeSession(input) {
       registerTurnSender,
       setTurnState,
       setMedia,
+      setMicrophoneFacts,
+      setAudioPlayback,
+      registerMediaControls,
       reset
     }),
     [
@@ -3251,6 +3558,12 @@ function useRealtimeSession(input) {
       endsAt,
       graceWindow,
       media,
+      microphone,
+      callAudioPlayback,
+      startAudio,
+      setMicrophoneEnabled,
+      microphoneMuted,
+      reconnect,
       sendClosingTurn,
       requestGracefulClose,
       extend,
@@ -3265,44 +3578,74 @@ function useRealtimeSession(input) {
       registerTurnSender,
       setTurnState,
       setMedia,
+      setMicrophoneFacts,
+      setAudioPlayback,
+      registerMediaControls,
       reset
     ]
   );
 }
 
+// ../http-client/src/retry.ts
+var PROXY_CLIENT_TIMEOUT_MS = 6e4;
+
 // ../client/src/proxy-client.ts
-var DEFAULT_TIMEOUT_MS = 6e4;
 var normalize = (url) => url.replace(/\/+$/, "");
 function createProxyClient(options) {
   const base = normalize(options.proxyUrl);
   const doFetch = options.fetch ?? globalThis.fetch?.bind(globalThis);
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const deadline = (caller) => {
-    if (!timeoutMs) return caller;
-    const timer = AbortSignal.timeout(timeoutMs);
-    return caller ? AbortSignal.any([caller, timer]) : timer;
-  };
+  const timeoutMs = options.timeoutMs ?? PROXY_CLIENT_TIMEOUT_MS;
+  const credentials = options.credentials;
+  const withCredentials = credentials === void 0 ? {} : { credentials };
   const post = async (path, body, request) => {
     if (!doFetch) throw new Error("realtime-avatar: no fetch available \u2014 pass one via `fetch`.");
-    return doFetch(`${base}${path}`, {
-      method: "POST",
-      headers: { "content-type": "application/json", ...request?.headers ?? {} },
-      body: JSON.stringify(body),
-      signal: deadline(request?.signal)
-    });
+    const caller = request?.signal;
+    const timer = timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0;
+    try {
+      return await doFetch(`${base}${path}`, {
+        method: "POST",
+        ...withCredentials,
+        headers: { "content-type": "application/json", ...request?.headers ?? {} },
+        body: JSON.stringify(body),
+        signal: timer && caller ? AbortSignal.any([caller, timer]) : timer ?? caller
+      });
+    } catch (cause) {
+      if (timer?.aborted && !caller?.aborted) throw RealtimeAvatarApiError.timeout(timeoutMs);
+      throw cause;
+    }
   };
-  const beacon = (path, body) => {
+  const pageHide = (body) => {
+    const page = globalThis.location?.href;
+    let target;
+    try {
+      target = new URL(`${base}/end`, page);
+    } catch {
+      return false;
+    }
+    const payload = JSON.stringify(body);
     const send = globalThis.navigator?.sendBeacon?.bind(globalThis.navigator);
-    if (!send) return false;
-    return send(`${base}${path}`, new Blob([JSON.stringify(body)], { type: "application/json" }));
+    const sameOrigin = page !== void 0 && target.origin === new URL(page).origin;
+    if (send && (sameOrigin || credentials === "include")) {
+      if (send(target.href, new Blob([payload], { type: "application/json" }))) return true;
+    }
+    if (!doFetch) return false;
+    try {
+      void doFetch(target.href, {
+        method: "POST",
+        keepalive: true,
+        ...withCredentials,
+        headers: { "content-type": "application/json" },
+        body: payload
+      }).catch(() => void 0);
+      return true;
+    } catch {
+      return false;
+    }
   };
   return {
     async createLiveKitSessionOrBusy(input, requestOptions) {
-      const response = await post(
-        "/connect",
-        { avatarId: input.avatarId, mode: input.mode },
-        requestOptions
-      );
+      const connect = { avatarId: input.avatarId, mode: input.mode };
+      const response = await post("/connect", connect, requestOptions);
       if (response.status === 429) {
         const value = await response.clone().json().catch(() => null);
         if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -3320,7 +3663,8 @@ function createProxyClient(options) {
     async releaseLiveKitSession(sessionId, reason, requestOptions) {
       if (!sessionId) return false;
       try {
-        const response = await post("/end", { session_id: sessionId, reason }, requestOptions);
+        const body = { session_id: sessionId, reason };
+        const response = await post("/end", body, requestOptions);
         return response.ok;
       } catch {
         return false;
@@ -3328,12 +3672,13 @@ function createProxyClient(options) {
     },
     releaseLiveKitSessionBeacon(sessionId, reason) {
       if (!sessionId) return false;
-      return beacon("/end", { session_id: sessionId, reason: reason ?? "page_hide" });
+      return pageHide({ session_id: sessionId, reason: reason ?? "page_hide" });
     },
     async releaseLiveKitQueueTicket(queueTicketId, reason, requestOptions) {
       if (!queueTicketId) return false;
       try {
-        const response = await post("/end", { queue_ticket_id: queueTicketId, reason }, requestOptions);
+        const body = { queue_ticket_id: queueTicketId, reason };
+        const response = await post("/end", body, requestOptions);
         return response.ok;
       } catch {
         return false;
@@ -3341,7 +3686,7 @@ function createProxyClient(options) {
     },
     releaseLiveKitQueueTicketBeacon(queueTicketId, reason) {
       if (!queueTicketId) return false;
-      return beacon("/end", { queue_ticket_id: queueTicketId, reason: reason ?? "page_hide" });
+      return pageHide({ queue_ticket_id: queueTicketId, reason: reason ?? "page_hide" });
     }
   };
 }