livekit-client 2.5.10 → 2.6.0

package/README.md

@@ -304,12 +304,66 @@ setLogExtension((level: LogLevel, msg: string, context: object) => {
 });
 ```
 
+### RPC
+
+Perform your own predefined method calls from one participant to another. 
+
+This feature is especially powerful when used with [Agents](https://docs.livekit.io/agents), for instance to forward LLM function calls to your client application.
+
+#### Registering an RPC method
+
+The participant who implements the method and will receive its calls must first register support:
+
+```typescript
+room.localParticipant?.registerRpcMethod(
+  // method name - can be any string that makes sense for your application
+  'greet',
+
+  // method handler - will be called when the method is invoked by a RemoteParticipant
+  async (data: RpcInvocationData) => {
+    console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
+    return `Hello, ${data.callerIdentity}!`;
+  }
+);
+```
+
+In addition to the payload, your handler will also receive `responseTimeout`, which informs you the maximum time available to return a response. If you are unable to respond in time, the call will result in an error on the caller's side.
+
+#### Performing an RPC request
+
+The caller may then initiate an RPC call like so:
+
+```typescript
+try {
+  const response = await room.localParticipant!.performRpc({
+    destinationIdentity: 'recipient-identity',
+    method: 'greet',
+    payload: 'Hello from RPC!',
+  });
+  console.log('RPC response:', response);
+} catch (error) {
+  console.error('RPC call failed:', error);
+}
+```
+
+You may find it useful to adjust the `responseTimeout` parameter, which indicates the amount of time you will wait for a response. We recommend keeping this value as low as possible while still satisfying the constraints of your application.
+
+#### Errors
+
+LiveKit is a dynamic realtime environment and calls can fail for various reasons. 
+
+You may throw errors of the type `RpcError` with a string `message` in an RPC method handler and they will be received on the caller's side with the message intact. Other errors will not be transmitted and will instead arrive to the caller as `1500` ("Application Error"). Other built-in errors are detailed in `RpcError`.
+
 ## Examples
 
 ### Demo App
 
 [examples/demo](examples/demo/) contains a demo webapp that uses the SDK. Run it with `pnpm install && pnpm examples:demo`
 
+### RPC Demo
+
+[examples/rpc](examples/rpc/) contains a demo webapp that uses the SDK to showcase the RPC capabilities. Run it with `pnpm install && pnpm dev` from the `examples/rpc` directory.
+
 ## Browser Support
 
 | Browser         | Desktop OS            | Mobile OS |

package/dist/livekit-client.esm.mjs

@@ -4746,14 +4746,14 @@ const RpcResponse = /*@__PURE__*/proto3.makeMessageType("livekit.RpcResponse", (
   no: 3,
   name: "error",
   kind: "message",
-  T: RpcError,
+  T: RpcError$1,
   oneof: "value"
 }]);
 
 /**
  * @generated from message livekit.RpcError
  */
-const RpcError = /*@__PURE__*/proto3.makeMessageType("livekit.RpcError", () => [{
+const RpcError$1 = /*@__PURE__*/proto3.makeMessageType("livekit.RpcError", () => [{
   no: 1,
   name: "code",
   kind: "scalar",
@@ -11176,7 +11176,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.5.10";
+var version$1 = "2.6.0";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11836,11 +11836,7 @@ function screenCaptureToDisplayMediaStreamOptions(options) {
   };
 }
 function mimeTypeToVideoCodecString(mimeType) {
-  const codec = mimeType.split('/')[1].toLowerCase();
-  if (!videoCodecs.includes(codec)) {
-    throw Error("Video codec not supported: ".concat(codec));
-  }
-  return codec;
+  return mimeType.split('/')[1].toLowerCase();
 }
 function getTrackPublicationInfo(tracks) {
   const infos = [];
@@ -14673,6 +14669,7 @@ class PCTransport extends eventsExports.EventEmitter {
     var _a;
     super();
     this.log = livekitLogger;
+    this.ddExtID = 0;
     this.pendingCandidates = [];
     this.restartingIce = false;
     this.renegotiate = false;
@@ -14894,7 +14891,7 @@ class PCTransport extends eventsExports.EventEmitter {
               return true;
             }
             if (isSVCCodec(trackbr.codec)) {
-              ensureVideoDDExtensionForSVC(media);
+              this.ensureVideoDDExtensionForSVC(media, sdpParsed);
             }
             // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
             // mung sdp for av1 bitrate setting that can't apply by sendEncoding
@@ -15081,6 +15078,36 @@ class PCTransport extends eventsExports.EventEmitter {
       }
     });
   }
+  ensureVideoDDExtensionForSVC(media, sdp) {
+    var _a, _b;
+    const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
+      if (ext.uri === ddExtensionURI) {
+        return true;
+      }
+      return false;
+    });
+    if (!ddFound) {
+      if (this.ddExtID === 0) {
+        let maxID = 0;
+        sdp.media.forEach(m => {
+          var _a;
+          if (m.type !== 'video') {
+            return;
+          }
+          (_a = m.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+            if (ext.value > maxID) {
+              maxID = ext.value;
+            }
+          });
+        });
+        this.ddExtID = maxID + 1;
+      }
+      (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
+        value: this.ddExtID,
+        uri: ddExtensionURI
+      });
+    }
+  }
 }
 function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
   // found opus codec to add nack fb
@@ -15116,25 +15143,6 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
     }
   }
 }
-function ensureVideoDDExtensionForSVC(media) {
-  var _a, _b;
-  let maxID = 0;
-  const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
-    if (ext.uri === ddExtensionURI) {
-      return true;
-    }
-    if (ext.value > maxID) {
-      maxID = ext.value;
-    }
-    return false;
-  });
-  if (!ddFound) {
-    (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
-      value: maxID + 1,
-      uri: ddExtensionURI
-    });
-  }
-}
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];
@@ -17865,6 +17873,120 @@ function getCloudConfigUrl(serverUrl) {
   return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }
 
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Specialized error handling for RPC methods.
+ *
+ * Instances of this type, when thrown in a method handler, will have their `message`
+ * serialized and sent across the wire. The sender will receive an equivalent error on the other side.
+ *
+ * Built-in types are included but developers may use any string, with a max length of 256 bytes.
+ */
+class RpcError extends Error {
+  /**
+   * Creates an error object with the given code and message, plus an optional data payload.
+   *
+   * If thrown in an RPC method handler, the error will be sent back to the caller.
+   *
+   * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
+   */
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.message = truncateBytes(message, RpcError.MAX_MESSAGE_BYTES);
+    this.data = data ? truncateBytes(data, RpcError.MAX_DATA_BYTES) : undefined;
+  }
+  /**
+   * @internal
+   */
+  static fromProto(proto) {
+    return new RpcError(proto.code, proto.message, proto.data);
+  }
+  /**
+   * @internal
+   */
+  toProto() {
+    return new RpcError$1({
+      code: this.code,
+      message: this.message,
+      data: this.data
+    });
+  }
+  /**
+   * Creates an error object from the code, with an auto-populated message.
+   *
+   * @internal
+   */
+  static builtIn(key, data) {
+    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data);
+  }
+}
+RpcError.MAX_MESSAGE_BYTES = 256;
+RpcError.MAX_DATA_BYTES = 15360; // 15 KB
+RpcError.ErrorCode = {
+  APPLICATION_ERROR: 1500,
+  CONNECTION_TIMEOUT: 1501,
+  RESPONSE_TIMEOUT: 1502,
+  RECIPIENT_DISCONNECTED: 1503,
+  RESPONSE_PAYLOAD_TOO_LARGE: 1504,
+  SEND_FAILED: 1505,
+  UNSUPPORTED_METHOD: 1400,
+  RECIPIENT_NOT_FOUND: 1401,
+  REQUEST_PAYLOAD_TOO_LARGE: 1402,
+  UNSUPPORTED_SERVER: 1403,
+  UNSUPPORTED_VERSION: 1404
+};
+/**
+ * @internal
+ */
+RpcError.ErrorMessage = {
+  APPLICATION_ERROR: 'Application error in method handler',
+  CONNECTION_TIMEOUT: 'Connection timeout',
+  RESPONSE_TIMEOUT: 'Response timeout',
+  RECIPIENT_DISCONNECTED: 'Recipient disconnected',
+  RESPONSE_PAYLOAD_TOO_LARGE: 'Response payload too large',
+  SEND_FAILED: 'Failed to send',
+  UNSUPPORTED_METHOD: 'Method not supported at destination',
+  RECIPIENT_NOT_FOUND: 'Recipient not found',
+  REQUEST_PAYLOAD_TOO_LARGE: 'Request payload too large',
+  UNSUPPORTED_SERVER: 'RPC not supported by server',
+  UNSUPPORTED_VERSION: 'Unsupported RPC version'
+};
+/*
+ * Maximum payload size for RPC requests and responses. If a payload exceeds this size,
+ * the RPC call will fail with a REQUEST_PAYLOAD_TOO_LARGE(1402) or RESPONSE_PAYLOAD_TOO_LARGE(1504) error.
+ */
+const MAX_PAYLOAD_BYTES = 15360; // 15 KB
+/**
+ * @internal
+ */
+function byteLength(str) {
+  const encoder = new TextEncoder();
+  return encoder.encode(str).length;
+}
+/**
+ * @internal
+ */
+function truncateBytes(str, maxBytes) {
+  if (byteLength(str) <= maxBytes) {
+    return str;
+  }
+  let low = 0;
+  let high = str.length;
+  const encoder = new TextEncoder();
+  while (low < high) {
+    const mid = Math.floor((low + high + 1) / 2);
+    if (encoder.encode(str.slice(0, mid)).length <= maxBytes) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return str.slice(0, low);
+}
+
 class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
     super(mediaTrack, kind, loggerOptions);
@@ -19100,6 +19222,9 @@ class LocalParticipant extends Participant {
     this.allParticipantsAllowedToSubscribe = true;
     this.encryptionType = Encryption_Type.NONE;
     this.enabledPublishVideoCodecs = [];
+    this.rpcHandlers = new Map();
+    this.pendingAcks = new Map();
+    this.pendingResponses = new Map();
     this.handleReconnecting = () => {
       if (!this.reconnectFuture) {
         this.reconnectFuture = new Future();
@@ -19133,6 +19258,29 @@ class LocalParticipant extends Participant {
         this.pendingSignalRequests.delete(requestId);
       }
     };
+    this.handleDataPacket = packet => {
+      switch (packet.value.case) {
+        case 'rpcRequest':
+          let rpcRequest = packet.value.value;
+          this.handleIncomingRpcRequest(packet.participantIdentity, rpcRequest.id, rpcRequest.method, rpcRequest.payload, rpcRequest.responseTimeoutMs, rpcRequest.version);
+          break;
+        case 'rpcResponse':
+          let rpcResponse = packet.value.value;
+          let payload = null;
+          let error = null;
+          if (rpcResponse.value.case === 'payload') {
+            payload = rpcResponse.value.value;
+          } else if (rpcResponse.value.case === 'error') {
+            error = RpcError.fromProto(rpcResponse.value.value);
+          }
+          this.handleIncomingRpcResponse(rpcResponse.requestId, payload, error);
+          break;
+        case 'rpcAck':
+          let rpcAck = packet.value.value;
+          this.handleIncomingRpcAck(rpcAck.requestId);
+          break;
+      }
+    };
     this.updateTrackSubscriptionPermissions = () => {
       this.log.debug('updating track subscription permissions', Object.assign(Object.assign({}, this.logContext), {
         allParticipantsAllowed: this.allParticipantsAllowedToSubscribe,
@@ -19320,7 +19468,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);
+    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);
   }
   /**
    * Sets and updates the metadata of the local participant.
@@ -20309,6 +20457,108 @@ class LocalParticipant extends Participant {
       return msg;
     });
   }
+  /**
+   * Initiate an RPC call to a remote participant
+   * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}
+   * @returns A promise that resolves with the response payload or rejects with an error.
+   * @throws Error on failure. Details in `message`.
+   */
+  performRpc(_a) {
+    return __awaiter(this, arguments, void 0, function (_ref3) {
+      var _this5 = this;
+      let {
+        destinationIdentity,
+        method,
+        payload,
+        responseTimeout = 10000
+      } = _ref3;
+      return function* () {
+        const maxRoundTripLatency = 2000;
+        return new Promise((resolve, reject) => __awaiter(_this5, void 0, void 0, function* () {
+          var _a, _b, _c, _d;
+          if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
+            reject(RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE'));
+            return;
+          }
+          if (((_b = (_a = this.engine.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.serverInfo) === null || _b === void 0 ? void 0 : _b.version) && compareVersions((_d = (_c = this.engine.latestJoinResponse) === null || _c === void 0 ? void 0 : _c.serverInfo) === null || _d === void 0 ? void 0 : _d.version, '1.8.0') < 0) {
+            reject(RpcError.builtIn('UNSUPPORTED_SERVER'));
+            return;
+          }
+          const id = crypto.randomUUID();
+          yield this.publishRpcRequest(destinationIdentity, id, method, payload, responseTimeout - maxRoundTripLatency);
+          const ackTimeoutId = setTimeout(() => {
+            this.pendingAcks.delete(id);
+            reject(RpcError.builtIn('CONNECTION_TIMEOUT'));
+            this.pendingResponses.delete(id);
+            clearTimeout(responseTimeoutId);
+          }, maxRoundTripLatency);
+          this.pendingAcks.set(id, {
+            resolve: () => {
+              clearTimeout(ackTimeoutId);
+            },
+            participantIdentity: destinationIdentity
+          });
+          const responseTimeoutId = setTimeout(() => {
+            this.pendingResponses.delete(id);
+            reject(RpcError.builtIn('RESPONSE_TIMEOUT'));
+          }, responseTimeout);
+          this.pendingResponses.set(id, {
+            resolve: (responsePayload, responseError) => {
+              clearTimeout(responseTimeoutId);
+              if (this.pendingAcks.has(id)) {
+                console.warn('RPC response received before ack', id);
+                this.pendingAcks.delete(id);
+                clearTimeout(ackTimeoutId);
+              }
+              if (responseError) {
+                reject(responseError);
+              } else {
+                resolve(responsePayload !== null && responsePayload !== void 0 ? responsePayload : '');
+              }
+            },
+            participantIdentity: destinationIdentity
+          });
+        }));
+      }();
+    });
+  }
+  /**
+   * Establishes the participant as a receiver for calls of the specified RPC method.
+   * Will overwrite any existing callback for the same method.
+   *
+   * @param method - The name of the indicated RPC method
+   * @param handler - Will be invoked when an RPC request for this method is received
+   * @returns A promise that resolves when the method is successfully registered
+   *
+   * @example
+   * ```typescript
+   * room.localParticipant?.registerRpcMethod(
+   *   'greet',
+   *   async (data: RpcInvocationData) => {
+   *     console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
+   *     return `Hello, ${data.callerIdentity}!`;
+   *   }
+   * );
+   * ```
+   *
+   * The handler should return a Promise that resolves to a string.
+   * If unable to respond within `responseTimeout`, the request will result in an error on the caller's side.
+   *
+   * You may throw errors of type `RpcError` with a string `message` in the handler,
+   * and they will be received on the caller's side with the message intact.
+   * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+   */
+  registerRpcMethod(method, handler) {
+    this.rpcHandlers.set(method, handler);
+  }
+  /**
+   * Unregisters a previously registered RPC method.
+   *
+   * @param method - The name of the RPC method to unregister
+   */
+  unregisterRpcMethod(method) {
+    this.rpcHandlers.delete(method);
+  }
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
    *
@@ -20334,6 +20584,140 @@ class LocalParticipant extends Participant {
       this.updateTrackSubscriptionPermissions();
     }
   }
+  handleIncomingRpcAck(requestId) {
+    const handler = this.pendingAcks.get(requestId);
+    if (handler) {
+      handler.resolve();
+      this.pendingAcks.delete(requestId);
+    } else {
+      console.error('Ack received for unexpected RPC request', requestId);
+    }
+  }
+  handleIncomingRpcResponse(requestId, payload, error) {
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      handler.resolve(payload, error);
+      this.pendingResponses.delete(requestId);
+    } else {
+      console.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+  handleIncomingRpcRequest(callerIdentity, requestId, method, payload, responseTimeout, version) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.publishRpcAck(callerIdentity, requestId);
+      if (version !== 1) {
+        yield this.publishRpcResponse(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_VERSION'));
+        return;
+      }
+      const handler = this.rpcHandlers.get(method);
+      if (!handler) {
+        yield this.publishRpcResponse(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_METHOD'));
+        return;
+      }
+      let responseError = null;
+      let responsePayload = null;
+      try {
+        const response = yield handler({
+          requestId,
+          callerIdentity,
+          payload,
+          responseTimeout
+        });
+        if (byteLength(response) > MAX_PAYLOAD_BYTES) {
+          responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
+          console.warn("RPC Response payload too large for ".concat(method));
+        } else {
+          responsePayload = response;
+        }
+      } catch (error) {
+        if (error instanceof RpcError) {
+          responseError = error;
+        } else {
+          console.warn("Uncaught error returned by RPC handler for ".concat(method, ". Returning APPLICATION_ERROR instead."), error);
+          responseError = RpcError.builtIn('APPLICATION_ERROR');
+        }
+      }
+      yield this.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
+    });
+  }
+  /** @internal */
+  publishRpcRequest(destinationIdentity, requestId, method, payload, responseTimeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const packet = new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcRequest',
+          value: new RpcRequest({
+            id: requestId,
+            method,
+            payload,
+            responseTimeoutMs: responseTimeout,
+            version: 1
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  publishRpcResponse(destinationIdentity, requestId, payload, error) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const packet = new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcResponse',
+          value: new RpcResponse({
+            requestId,
+            value: error ? {
+              case: 'error',
+              value: error.toProto()
+            } : {
+              case: 'payload',
+              value: payload !== null && payload !== void 0 ? payload : ''
+            }
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  publishRpcAck(destinationIdentity, requestId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const packet = new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcAck',
+          value: new RpcAck({
+            requestId
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  handleParticipantDisconnected(participantIdentity) {
+    for (const [id, {
+      participantIdentity: pendingIdentity
+    }] of this.pendingAcks) {
+      if (pendingIdentity === participantIdentity) {
+        this.pendingAcks.delete(id);
+      }
+    }
+    for (const [id, {
+      participantIdentity: pendingIdentity,
+      resolve
+    }] of this.pendingResponses) {
+      if (pendingIdentity === participantIdentity) {
+        resolve(null, RpcError.builtIn('RECIPIENT_DISCONNECTED'));
+        this.pendingResponses.delete(id);
+      }
+    }
+  }
   /** @internal */
   setEnabledPublishCodecs(codecs) {
     this.enabledPublishVideoCodecs = codecs.filter(c => c.mime.split('/')[0].toLowerCase() === 'video');
@@ -20388,8 +20772,8 @@ class LocalParticipant extends Participant {
   }
   waitForPendingPublicationOfSource(source) {
     return __awaiter(this, void 0, void 0, function* () {
-      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref3 => {
-        let [pendingTrack] = _ref3;
+      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref4 => {
+        let [pendingTrack] = _ref4;
         return pendingTrack.source === source;
       });
       if (publishPromiseEntry) {
@@ -22210,6 +22594,7 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   handleParticipantDisconnected(identity, participant) {
+    var _a;
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -22219,6 +22604,7 @@ class Room extends eventsExports.EventEmitter {
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
+    (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.handleParticipantDisconnected(participant.identity);
   }
   acquireAudioContext() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23096,5 +23482,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, 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, h as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, extractProcessorsFromOptions, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, 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, h as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, extractProcessorsFromOptions, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map