livekit-client 2.13.1 → 2.13.3

package/dist/livekit-client.esm.mjs

@@ -11181,6 +11181,10 @@ var TrackEvent;
    * @experimental
    */
   TrackEvent["TimeSyncUpdate"] = "timeSyncUpdate";
+  /**
+   * @internal
+   */
+  TrackEvent["PreConnectBufferFlushed"] = "preConnectBufferFlushed";
 })(TrackEvent || (TrackEvent = {}));
 
 function cloneDeep(value) {
@@ -11262,7 +11266,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.13.1";
+var version$1 = "2.13.3";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -15080,7 +15084,8 @@ const publishDefaults = {
   screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
   videoCodec: defaultVideoCodec,
-  backupCodec: true
+  backupCodec: true,
+  preConnectBuffer: false
 };
 const audioDefaults = {
   deviceId: {
@@ -15528,7 +15533,66 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-const defaultDimensionsTimeout = 1000;
+// Check if MediaRecorder is available
+const isMediaRecorderAvailable = typeof MediaRecorder !== 'undefined';
+// Fallback class for environments without MediaRecorder
+class FallbackRecorder {
+  constructor() {
+    throw new Error('MediaRecorder is not available in this environment');
+  }
+}
+// Use conditional inheritance to avoid parse-time errors
+const RecorderBase = isMediaRecorderAvailable ? MediaRecorder : FallbackRecorder;
+class LocalTrackRecorder extends RecorderBase {
+  constructor(track, options) {
+    if (!isMediaRecorderAvailable) {
+      throw new Error('MediaRecorder is not available in this environment');
+    }
+    super(new MediaStream([track.mediaStreamTrack]), options);
+    let dataListener;
+    let streamController;
+    const isClosed = () => streamController === undefined;
+    const onStop = () => {
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController === null || streamController === void 0 ? void 0 : streamController.close();
+      streamController = undefined;
+    };
+    const onError = event => {
+      streamController === null || streamController === void 0 ? void 0 : streamController.error(event);
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController = undefined;
+    };
+    this.byteStream = new ReadableStream({
+      start: controller => {
+        streamController = controller;
+        dataListener = event => __awaiter(this, void 0, void 0, function* () {
+          const arrayBuffer = yield event.data.arrayBuffer();
+          if (isClosed()) {
+            return;
+          }
+          controller.enqueue(new Uint8Array(arrayBuffer));
+        });
+        this.addEventListener('dataavailable', dataListener);
+      },
+      cancel: () => {
+        onStop();
+      }
+    });
+    this.addEventListener('stop', onStop);
+    this.addEventListener('error', onError);
+  }
+}
+// Helper function to check if recording is supported
+function isRecordingSupported() {
+  return isMediaRecorderAvailable;
+}
+
+const DEFAULT_DIMENSIONS_TIMEOUT = 1000;
+const PRE_CONNECT_BUFFER_TIMEOUT = 10000;
 class LocalTrack extends Track {
   /** @internal */
   get sender() {
@@ -15541,6 +15605,9 @@ class LocalTrack extends Track {
   get constraints() {
     return this._constraints;
   }
+  get hasPreConnectBuffer() {
+    return !!this.localTrackRecorder;
+  }
   /**
    *
    * @param mediaTrack
@@ -15696,7 +15763,7 @@ class LocalTrack extends Track {
   waitForDimensions() {
     return __awaiter(this, arguments, void 0, function () {
       var _this = this;
-      let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultDimensionsTimeout;
+      let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_DIMENSIONS_TIMEOUT;
       return function* () {
         var _a;
         if (_this.kind === Track.Kind.Audio) {
@@ -16051,6 +16118,40 @@ class LocalTrack extends Track {
       }();
     });
   }
+  /** @internal */
+  startPreConnectBuffer() {
+    let timeslice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
+    if (!isRecordingSupported()) {
+      this.log.warn('MediaRecorder is not available, cannot start preconnect buffer', this.logContext);
+      return;
+    }
+    if (!this.localTrackRecorder) {
+      this.localTrackRecorder = new LocalTrackRecorder(this, {
+        mimeType: 'audio/webm;codecs=opus'
+      });
+    } else {
+      this.log.warn('preconnect buffer already started');
+      return;
+    }
+    this.localTrackRecorder.start(timeslice);
+    this.autoStopPreConnectBuffer = setTimeout(() => {
+      this.log.warn('preconnect buffer timed out, stopping recording automatically', this.logContext);
+      this.stopPreConnectBuffer();
+    }, PRE_CONNECT_BUFFER_TIMEOUT);
+  }
+  /** @internal */
+  stopPreConnectBuffer() {
+    clearTimeout(this.autoStopPreConnectBuffer);
+    if (this.localTrackRecorder) {
+      this.localTrackRecorder.stop();
+      this.localTrackRecorder = undefined;
+    }
+  }
+  /** @internal */
+  getPreConnectBuffer() {
+    var _a;
+    return (_a = this.localTrackRecorder) === null || _a === void 0 ? void 0 : _a.byteStream;
+  }
 }
 
 class LocalAudioTrack extends LocalTrack {
@@ -17497,10 +17598,7 @@ class RTCEngine extends eventsExports.EventEmitter {
           this.negotiate();
         }
         this.clientConfiguration = joinResponse.clientConfiguration;
-        // emit signal connected event after a short delay to allow for join response to be processed on room
-        setTimeout(() => {
-          this.emit(EngineEvent.SignalConnected);
-        }, 10);
+        this.emit(EngineEvent.SignalConnected, joinResponse);
         return joinResponse;
       } catch (e) {
         if (e instanceof ConnectionError) {
@@ -20053,12 +20151,29 @@ class LocalParticipant extends Participant {
       this.updateTrackSubscriptionPermissions();
     };
     this.handleDisconnected = () => {
-      var _a, _b;
+      var _a, _b, _c, _d, _e, _f;
       if (this.reconnectFuture) {
         this.reconnectFuture.promise.catch(e => this.log.warn(e.message, this.logContext));
         (_b = (_a = this.reconnectFuture) === null || _a === void 0 ? void 0 : _a.reject) === null || _b === void 0 ? void 0 : _b.call(_a, 'Got disconnected during reconnection attempt');
         this.reconnectFuture = undefined;
       }
+      if (this.signalConnectedFuture) {
+        (_d = (_c = this.signalConnectedFuture).reject) === null || _d === void 0 ? void 0 : _d.call(_c, 'Got disconnected without signal connected');
+        this.signalConnectedFuture = undefined;
+      }
+      (_f = (_e = this.activeAgentFuture) === null || _e === void 0 ? void 0 : _e.reject) === null || _f === void 0 ? void 0 : _f.call(_e, 'Got disconnected without active agent present');
+      this.activeAgentFuture = undefined;
+      this.firstActiveAgent = undefined;
+    };
+    this.handleSignalConnected = joinResponse => {
+      var _a, _b;
+      if (joinResponse.participant) {
+        this.updateInfo(joinResponse.participant);
+      }
+      if (!this.signalConnectedFuture) {
+        this.signalConnectedFuture = new Future();
+      }
+      (_b = (_a = this.signalConnectedFuture).resolve) === null || _b === void 0 ? void 0 : _b.call(_a);
     };
     this.handleSignalRequestResponse = response => {
       const {
@@ -20277,7 +20392,7 @@ class LocalParticipant extends Participant {
         pub.unmute();
       }
     });
-    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalRestarted, this.handleReconnected).on(EngineEvent.SignalResumed, this.handleReconnected).on(EngineEvent.Restarting, this.handleReconnecting).on(EngineEvent.Resuming, this.handleReconnecting).on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished).on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate).on(EngineEvent.Disconnected, this.handleDisconnected).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse).on(EngineEvent.DataPacketReceived, this.handleDataPacket);
+    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalConnected, this.handleSignalConnected).on(EngineEvent.SignalRestarted, this.handleReconnected).on(EngineEvent.SignalResumed, this.handleReconnected).on(EngineEvent.Restarting, this.handleReconnecting).on(EngineEvent.Resuming, this.handleReconnecting).on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished).on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate).on(EngineEvent.Disconnected, this.handleDisconnected).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse).on(EngineEvent.DataPacketReceived, this.handleDataPacket);
   }
   /**
    * Sets and updates the metadata of the local participant.
@@ -20460,6 +20575,12 @@ class LocalParticipant extends Participant {
             this.pendingPublishing.delete(source);
             throw e;
           }
+          for (const localTrack of localTracks) {
+            if (source === Track.Source.Microphone && isAudioTrack(localTrack) && (publishOptions === null || publishOptions === void 0 ? void 0 : publishOptions.preConnectBuffer)) {
+              this.log.info('starting preconnect buffer for microphone', Object.assign({}, this.logContext));
+              localTrack.startPreConnectBuffer();
+            }
+          }
           try {
             const publishPromises = [];
             for (const localTrack of localTracks) {
@@ -20734,23 +20855,13 @@ class LocalParticipant extends Participant {
               this.log.debug('deferring track publication until signal is connected', Object.assign(Object.assign({}, this.logContext), {
                 track: getLogContextFromTrack(track)
               }));
-              const onSignalConnected = () => __awaiter(this, void 0, void 0, function* () {
-                try {
-                  const publication = yield this.publish(track, opts, isStereo);
-                  resolve(publication);
-                } catch (e) {
-                  reject(e);
-                }
-              });
-              setTimeout(() => {
-                this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+              const timeout = setTimeout(() => {
                 reject(new PublishTrackError('publishing rejected as engine not connected within timeout', 408));
               }, 15000);
-              this.engine.once(EngineEvent.SignalConnected, onSignalConnected);
-              this.engine.on(EngineEvent.Closing, () => {
-                this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
-                reject(new PublishTrackError('publishing rejected as engine closed', 499));
-              });
+              yield this.waitUntilEngineConnected();
+              clearTimeout(timeout);
+              const publication = yield this.publish(track, opts, isStereo);
+              resolve(publication);
             } else {
               try {
                 const publication = yield this.publish(track, opts, isStereo);
@@ -20775,6 +20886,12 @@ class LocalParticipant extends Participant {
       }();
     });
   }
+  waitUntilEngineConnected() {
+    if (!this.signalConnectedFuture) {
+      this.signalConnectedFuture = new Future();
+    }
+    return this.signalConnectedFuture.promise;
+  }
   hasPermissionsToPublish(track) {
     if (!this.permissions) {
       this.log.warn('no permissions present for publishing track', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
@@ -20832,6 +20949,27 @@ class LocalParticipant extends Participant {
       track.on(TrackEvent.UpstreamPaused, this.onTrackUpstreamPaused);
       track.on(TrackEvent.UpstreamResumed, this.onTrackUpstreamResumed);
       track.on(TrackEvent.AudioTrackFeatureUpdate, this.onTrackFeatureUpdate);
+      const audioFeatures = [];
+      const disableDtx = !((_a = opts.dtx) !== null && _a !== void 0 ? _a : true);
+      const settings = track.getSourceTrackSettings();
+      if (settings.autoGainControl) {
+        audioFeatures.push(AudioTrackFeature.TF_AUTO_GAIN_CONTROL);
+      }
+      if (settings.echoCancellation) {
+        audioFeatures.push(AudioTrackFeature.TF_ECHO_CANCELLATION);
+      }
+      if (settings.noiseSuppression) {
+        audioFeatures.push(AudioTrackFeature.TF_NOISE_SUPPRESSION);
+      }
+      if (settings.channelCount && settings.channelCount > 1) {
+        audioFeatures.push(AudioTrackFeature.TF_STEREO);
+      }
+      if (disableDtx) {
+        audioFeatures.push(AudioTrackFeature.TF_NO_DTX);
+      }
+      if (isLocalAudioTrack(track) && track.hasPreConnectBuffer) {
+        audioFeatures.push(AudioTrackFeature.TF_PRECONNECT_BUFFER);
+      }
       // create track publication from track
       const req = new AddTrackRequest({
         // get local track id for use during publishing
@@ -20840,12 +20978,13 @@ class LocalParticipant extends Participant {
         type: Track.kindToProto(track.kind),
         muted: track.isMuted,
         source: Track.sourceToProto(track.source),
-        disableDtx: !((_a = opts.dtx) !== null && _a !== void 0 ? _a : true),
+        disableDtx,
         encryption: this.encryptionType,
         stereo: isStereo,
         disableRed: this.isE2EEEnabled || !((_b = opts.red) !== null && _b !== void 0 ? _b : true),
         stream: opts === null || opts === void 0 ? void 0 : opts.stream,
-        backupCodecPolicy: opts === null || opts === void 0 ? void 0 : opts.backupCodecPolicy
+        backupCodecPolicy: opts === null || opts === void 0 ? void 0 : opts.backupCodecPolicy,
+        audioFeatures
       });
       // compute encodings and layers for video
       let encodings;
@@ -21033,6 +21172,75 @@ class LocalParticipant extends Participant {
       this.addTrackPublication(publication);
       // send event for publication
       this.emit(ParticipantEvent.LocalTrackPublished, publication);
+      if (isLocalAudioTrack(track) && ti.audioFeatures.includes(AudioTrackFeature.TF_PRECONNECT_BUFFER)) {
+        const stream = track.getPreConnectBuffer();
+        // TODO: we're registering the listener after negotiation, so there might be a race
+        this.on(ParticipantEvent.LocalTrackSubscribed, pub => {
+          if (pub.trackSid === ti.sid) {
+            if (!track.hasPreConnectBuffer) {
+              this.log.warn('subscribe event came to late, buffer already closed', this.logContext);
+              return;
+            }
+            this.log.debug('finished recording preconnect buffer', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
+            track.stopPreConnectBuffer();
+          }
+        });
+        if (stream) {
+          const bufferStreamPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
+            var _d, _e;
+            try {
+              this.log.debug('waiting for agent', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
+              const agentActiveTimeout = setTimeout(() => {
+                reject(new Error('agent not active within 10 seconds'));
+              }, 10000);
+              const agent = yield this.waitUntilActiveAgentPresent();
+              clearTimeout(agentActiveTimeout);
+              this.log.debug('sending preconnect buffer', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
+              const writer = yield this.streamBytes({
+                name: 'preconnect-buffer',
+                mimeType: 'audio/opus',
+                topic: 'lk.agent.pre-connect-audio-buffer',
+                destinationIdentities: [agent.identity],
+                attributes: {
+                  trackId: publication.trackSid,
+                  sampleRate: String((_d = settings.sampleRate) !== null && _d !== void 0 ? _d : '48000'),
+                  channels: String((_e = settings.channelCount) !== null && _e !== void 0 ? _e : '1')
+                }
+              });
+              try {
+                for (var _f = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _f = true) {
+                  _c = stream_1_1.value;
+                  _f = false;
+                  const chunk = _c;
+                  yield writer.write(chunk);
+                }
+              } catch (e_2_1) {
+                e_2 = {
+                  error: e_2_1
+                };
+              } finally {
+                try {
+                  if (!_f && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                } finally {
+                  if (e_2) throw e_2.error;
+                }
+              }
+              yield writer.close();
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          }));
+          bufferStreamPromise.then(() => {
+            this.log.debug('preconnect buffer sent successfully', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
+          }).catch(e => {
+            this.log.error('error sending preconnect buffer', Object.assign(Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)), {
+              error: e
+            }));
+          });
+        }
+      }
       return publication;
     });
   }
@@ -21781,6 +21989,29 @@ class LocalParticipant extends Participant {
     });
     return true;
   }
+  /** @internal */
+  setActiveAgent(agent) {
+    var _a, _b, _c, _d;
+    this.firstActiveAgent = agent;
+    if (agent && !this.firstActiveAgent) {
+      this.firstActiveAgent = agent;
+    }
+    if (agent) {
+      (_b = (_a = this.activeAgentFuture) === null || _a === void 0 ? void 0 : _a.resolve) === null || _b === void 0 ? void 0 : _b.call(_a, agent);
+    } else {
+      (_d = (_c = this.activeAgentFuture) === null || _c === void 0 ? void 0 : _c.reject) === null || _d === void 0 ? void 0 : _d.call(_c, 'Agent disconnected');
+    }
+    this.activeAgentFuture = undefined;
+  }
+  waitUntilActiveAgentPresent() {
+    if (this.firstActiveAgent) {
+      return Promise.resolve(this.firstActiveAgent);
+    }
+    if (!this.activeAgentFuture) {
+      this.activeAgentFuture = new Future();
+    }
+    return this.activeAgentFuture.promise;
+  }
   getPublicationForTrack(track) {
     let publication;
     this.trackPublications.forEach(pub => {
@@ -22974,51 +23205,10 @@ class Room extends eventsExports.EventEmitter {
       }
     };
     this.handleDeviceChange = () => __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c;
-      const previousDevices = DeviceManager.getInstance().previousDevices;
-      // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
-      const availableDevices = yield DeviceManager.getInstance().getDevices(undefined, false);
-      const browser = getBrowser();
-      if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && browser.os !== 'iOS') {
-        for (let availableDevice of availableDevices) {
-          const previousDevice = previousDevices.find(info => info.deviceId === availableDevice.deviceId);
-          if (previousDevice && previousDevice.label !== '' && previousDevice.kind === availableDevice.kind && previousDevice.label !== availableDevice.label) {
-            // label has changed on device the same deviceId, indicating that the default device has changed on the OS level
-            if (this.getActiveDevice(availableDevice.kind) === 'default') {
-              // emit an active device change event only if the selected output device is actually on `default`
-              this.emit(RoomEvent.ActiveDeviceChanged, availableDevice.kind, availableDevice.deviceId);
-            }
-          }
-        }
-      }
-      const kinds = ['audiooutput', 'audioinput', 'videoinput'];
-      for (let kind of kinds) {
-        const targetSource = kindToSource(kind);
-        const targetPublication = this.localParticipant.getTrackPublication(targetSource);
-        if (targetPublication && ((_a = targetPublication.track) === null || _a === void 0 ? void 0 : _a.isUserProvided)) {
-          // if the track is user provided, we don't want to switch devices on behalf of the user
-          continue;
-        }
-        const devicesOfKind = availableDevices.filter(d => d.kind === kind);
-        const activeDevice = this.getActiveDevice(kind);
-        if (activeDevice === ((_b = previousDevices.filter(info => info.kind === kind)[0]) === null || _b === void 0 ? void 0 : _b.deviceId)) {
-          // in  Safari the first device is always the default, so we assume a user on the default device would like to switch to the default once it changes
-          // FF doesn't emit an event when the default device changes, so we perform the same best effort and switch to the new device once connected and if it's the first in the array
-          if (devicesOfKind.length > 0 && ((_c = devicesOfKind[0]) === null || _c === void 0 ? void 0 : _c.deviceId) !== activeDevice) {
-            yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
-            continue;
-          }
-        }
-        if (kind === 'audioinput' && !isSafariBased() || kind === 'videoinput') {
-          // airpods on Safari need special handling for audioinput as the track doesn't end as soon as you take them out
-          continue;
-        }
-        // switch to first available device if previously active device is not available any more
-        if (devicesOfKind.length > 0 && !devicesOfKind.find(deviceInfo => deviceInfo.deviceId === this.getActiveDevice(kind)) && (
-        // avoid switching audio output on safari without explicit user action as it leads to slowed down audio playback
-        kind !== 'audiooutput' || !isSafariBased())) {
-          yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
-        }
+      var _a;
+      if (((_a = getBrowser()) === null || _a === void 0 ? void 0 : _a.os) !== 'iOS') {
+        // default devices are non deterministic on iOS, so we don't attempt to select them here
+        yield this.selectDefaultDevices();
       }
       this.emit(RoomEvent.MediaDevicesChanged);
     });
@@ -23923,6 +24113,59 @@ class Room extends eventsExports.EventEmitter {
       }
     }
   }
+  /**
+   * attempt to select the default devices if the previously selected devices are no longer available after a device change event
+   */
+  selectDefaultDevices() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c;
+      const previousDevices = DeviceManager.getInstance().previousDevices;
+      // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
+      const availableDevices = yield DeviceManager.getInstance().getDevices(undefined, false);
+      const browser = getBrowser();
+      if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && browser.os !== 'iOS') {
+        for (let availableDevice of availableDevices) {
+          const previousDevice = previousDevices.find(info => info.deviceId === availableDevice.deviceId);
+          if (previousDevice && previousDevice.label !== '' && previousDevice.kind === availableDevice.kind && previousDevice.label !== availableDevice.label) {
+            // label has changed on device the same deviceId, indicating that the default device has changed on the OS level
+            if (this.getActiveDevice(availableDevice.kind) === 'default') {
+              // emit an active device change event only if the selected output device is actually on `default`
+              this.emit(RoomEvent.ActiveDeviceChanged, availableDevice.kind, availableDevice.deviceId);
+            }
+          }
+        }
+      }
+      const kinds = ['audiooutput', 'audioinput', 'videoinput'];
+      for (let kind of kinds) {
+        const targetSource = kindToSource(kind);
+        const targetPublication = this.localParticipant.getTrackPublication(targetSource);
+        if (targetPublication && ((_a = targetPublication.track) === null || _a === void 0 ? void 0 : _a.isUserProvided)) {
+          // if the track is user provided, we don't want to switch devices on behalf of the user
+          continue;
+        }
+        const devicesOfKind = availableDevices.filter(d => d.kind === kind);
+        const activeDevice = this.getActiveDevice(kind);
+        if (activeDevice === ((_b = previousDevices.filter(info => info.kind === kind)[0]) === null || _b === void 0 ? void 0 : _b.deviceId)) {
+          // in  Safari the first device is always the default, so we assume a user on the default device would like to switch to the default once it changes
+          // FF doesn't emit an event when the default device changes, so we perform the same best effort and switch to the new device once connected and if it's the first in the array
+          if (devicesOfKind.length > 0 && ((_c = devicesOfKind[0]) === null || _c === void 0 ? void 0 : _c.deviceId) !== activeDevice) {
+            yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
+            continue;
+          }
+        }
+        if (kind === 'audioinput' && !isSafariBased() || kind === 'videoinput') {
+          // airpods on Safari need special handling for audioinput as the track doesn't end as soon as you take them out
+          continue;
+        }
+        // switch to first available device if previously active device is not available any more
+        if (devicesOfKind.length > 0 && !devicesOfKind.find(deviceInfo => deviceInfo.deviceId === this.getActiveDevice(kind)) && (
+        // avoid switching audio output on safari without explicit user action as it leads to slowed down audio playback
+        kind !== 'audiooutput' || !isSafariBased())) {
+          yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
+        }
+      }
+    });
+  }
   acquireAudioContext() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b;
@@ -24036,6 +24279,9 @@ class Room extends eventsExports.EventEmitter {
       this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, status, participant);
     }).on(ParticipantEvent.Active, () => {
       this.emitWhenConnected(RoomEvent.ParticipantActive, participant);
+      if (participant.kind === ParticipantInfo_Kind.AGENT) {
+        this.localParticipant.setActiveAgent(participant);
+      }
     });
     // update info at the end after callbacks have been set up
     if (info) {
@@ -25091,5 +25337,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map