livekit-client 1.6.4 → 1.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.6.4",
+  "version": "1.6.5",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

package/src/api/SignalClient.ts

@@ -5,6 +5,7 @@ import {
   ClientInfo,
   DisconnectReason,
   ParticipantInfo,
+  ReconnectReason,
   Room,
   SpeakerInfo,
   VideoLayer,
@@ -40,6 +41,9 @@ interface ConnectOpts {
   /** internal */
   reconnect?: boolean;
 
+  /** internal */
+  reconnectReason?: number;
+
   /** internal */
   sid?: string;
 
@@ -89,6 +93,9 @@ export class SignalClient {
 
   useJSON: boolean;
 
+  /** signal rtt in milliseconds */
+  rtt: number = 0;
+
   /** simulate signaling latency by delaying messages */
   signalLatency?: number;
 
@@ -166,7 +173,12 @@ export class SignalClient {
     return res as JoinResponse;
   }
 
-  async reconnect(url: string, token: string, sid?: string): Promise<ReconnectResponse | void> {
+  async reconnect(
+    url: string,
+    token: string,
+    sid?: string,
+    reason?: ReconnectReason,
+  ): Promise<ReconnectResponse | void> {
     if (!this.options) {
       log.warn('attempted to reconnect without signal options being set, ignoring');
       return;
@@ -175,7 +187,12 @@ export class SignalClient {
     // clear ping interval and restart it once reconnected
     this.clearPingInterval();
 
-    const res = await this.connect(url, token, { ...this.options, reconnect: true, sid });
+    const res = await this.connect(url, token, {
+      ...this.options,
+      reconnect: true,
+      sid,
+      reconnectReason: reason,
+    });
     return res;
   }
 
@@ -440,10 +457,18 @@ export class SignalClient {
   }
 
   sendPing() {
+    /** send both of ping and pingReq for compatibility to old and new server */
     this.sendRequest({
       $case: 'ping',
       ping: Date.now(),
     });
+    this.sendRequest({
+      $case: 'pingReq',
+      pingReq: {
+        timestamp: Date.now(),
+        rtt: this.rtt,
+      },
+    });
   }
 
   async sendLeave() {
@@ -563,6 +588,9 @@ export class SignalClient {
       }
     } else if (msg.$case === 'pong') {
       this.resetPingTimeout();
+    } else if (msg.$case === 'pongResp') {
+      this.rtt = Date.now() - msg.pongResp.lastPingTimestamp;
+      this.resetPingTimeout();
     } else {
       log.debug('unsupported message', msg);
     }
@@ -582,6 +610,10 @@ export class SignalClient {
     log.error('websocket error', ev);
   }
 
+  /**
+   * Resets the ping timeout and starts a new timeout.
+   * Call this after receiving a pong message
+   */
   private resetPingTimeout() {
     this.clearPingTimeout();
     if (!this.pingTimeoutDuration) {
@@ -600,6 +632,9 @@ export class SignalClient {
     }, this.pingTimeoutDuration * 1000);
   }
 
+  /**
+   * Clears ping timeout (does not start a new timeout)
+   */
   private clearPingTimeout() {
     if (this.pingTimeout) {
       CriticalTimers.clearTimeout(this.pingTimeout);
@@ -698,6 +733,10 @@ function createConnectionParams(token: string, info: ClientInfo, opts: ConnectOp
     params.set('adaptive_stream', '1');
   }
 
+  if (opts.reconnectReason) {
+    params.set('reconnect_reason', opts.reconnectReason.toString());
+  }
+
   // @ts-ignore
   if (navigator.connection?.type) {
     // @ts-ignore

package/src/proto/livekit_models.ts

@@ -287,6 +287,57 @@ export function disconnectReasonToJSON(object: DisconnectReason): string {
   }
 }
 
+export enum ReconnectReason {
+  REASON_UNKOWN = 0,
+  REASON_SIGNAL_DISCONNECTED = 1,
+  REASON_PUBLISHER_FAILED = 2,
+  REASON_SUBSCRIBER_FAILED = 3,
+  REASON_SWITCH_CANDIDATE = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function reconnectReasonFromJSON(object: any): ReconnectReason {
+  switch (object) {
+    case 0:
+    case "REASON_UNKOWN":
+      return ReconnectReason.REASON_UNKOWN;
+    case 1:
+    case "REASON_SIGNAL_DISCONNECTED":
+      return ReconnectReason.REASON_SIGNAL_DISCONNECTED;
+    case 2:
+    case "REASON_PUBLISHER_FAILED":
+      return ReconnectReason.REASON_PUBLISHER_FAILED;
+    case 3:
+    case "REASON_SUBSCRIBER_FAILED":
+      return ReconnectReason.REASON_SUBSCRIBER_FAILED;
+    case 4:
+    case "REASON_SWITCH_CANDIDATE":
+      return ReconnectReason.REASON_SWITCH_CANDIDATE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ReconnectReason.UNRECOGNIZED;
+  }
+}
+
+export function reconnectReasonToJSON(object: ReconnectReason): string {
+  switch (object) {
+    case ReconnectReason.REASON_UNKOWN:
+      return "REASON_UNKOWN";
+    case ReconnectReason.REASON_SIGNAL_DISCONNECTED:
+      return "REASON_SIGNAL_DISCONNECTED";
+    case ReconnectReason.REASON_PUBLISHER_FAILED:
+      return "REASON_PUBLISHER_FAILED";
+    case ReconnectReason.REASON_SUBSCRIBER_FAILED:
+      return "REASON_SUBSCRIBER_FAILED";
+    case ReconnectReason.REASON_SWITCH_CANDIDATE:
+      return "REASON_SWITCH_CANDIDATE";
+    case ReconnectReason.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface Room {
   sid: string;
   name: string;

package/src/proto/livekit_rtc.ts

@@ -152,7 +152,8 @@ export interface SignalRequest {
     | { $case: "syncState"; syncState: SyncState }
     | { $case: "simulate"; simulate: SimulateScenario }
     | { $case: "ping"; ping: number }
-    | { $case: "updateMetadata"; updateMetadata: UpdateParticipantMetadata };
+    | { $case: "updateMetadata"; updateMetadata: UpdateParticipantMetadata }
+    | { $case: "pingReq"; pingReq: Ping };
 }
 
 export interface SignalResponse {
@@ -174,7 +175,8 @@ export interface SignalResponse {
     | { $case: "refreshToken"; refreshToken: string }
     | { $case: "trackUnpublished"; trackUnpublished: TrackUnpublishedResponse }
     | { $case: "pong"; pong: number }
-    | { $case: "reconnect"; reconnect: ReconnectResponse };
+    | { $case: "reconnect"; reconnect: ReconnectResponse }
+    | { $case: "pongResp"; pongResp: Pong };
 }
 
 export interface SimulcastCodec {
@@ -241,6 +243,9 @@ export interface JoinResponse {
 export interface ReconnectResponse {
   iceServers: ICEServer[];
   clientConfiguration?: ClientConfiguration;
+  room?: Room;
+  participant?: ParticipantInfo;
+  otherParticipants: ParticipantInfo[];
 }
 
 export interface TrackPublishedResponse {
@@ -404,6 +409,18 @@ export interface SimulateScenario {
     | { $case: "switchCandidateProtocol"; switchCandidateProtocol: CandidateProtocol };
 }
 
+export interface Ping {
+  timestamp: number;
+  /** rtt in milliseconds calculated by client */
+  rtt: number;
+}
+
+export interface Pong {
+  /** timestamp field of last received ping request */
+  lastPingTimestamp: number;
+  timestamp: number;
+}
+
 function createBaseSignalRequest(): SignalRequest {
   return { message: undefined };
 }
@@ -452,6 +469,9 @@ export const SignalRequest = {
     if (message.message?.$case === "updateMetadata") {
       UpdateParticipantMetadata.encode(message.message.updateMetadata, writer.uint32(122).fork()).ldelim();
     }
+    if (message.message?.$case === "pingReq") {
+      Ping.encode(message.message.pingReq, writer.uint32(130).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -513,6 +533,9 @@ export const SignalRequest = {
             updateMetadata: UpdateParticipantMetadata.decode(reader, reader.uint32()),
           };
           break;
+        case 16:
+          message.message = { $case: "pingReq", pingReq: Ping.decode(reader, reader.uint32()) };
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -554,6 +577,8 @@ export const SignalRequest = {
         ? { $case: "ping", ping: Number(object.ping) }
         : isSet(object.updateMetadata)
         ? { $case: "updateMetadata", updateMetadata: UpdateParticipantMetadata.fromJSON(object.updateMetadata) }
+        : isSet(object.pingReq)
+        ? { $case: "pingReq", pingReq: Ping.fromJSON(object.pingReq) }
         : undefined,
     };
   },
@@ -593,6 +618,8 @@ export const SignalRequest = {
     message.message?.$case === "updateMetadata" && (obj.updateMetadata = message.message?.updateMetadata
       ? UpdateParticipantMetadata.toJSON(message.message?.updateMetadata)
       : undefined);
+    message.message?.$case === "pingReq" &&
+      (obj.pingReq = message.message?.pingReq ? Ping.toJSON(message.message?.pingReq) : undefined);
     return obj;
   },
 
@@ -689,6 +716,11 @@ export const SignalRequest = {
         updateMetadata: UpdateParticipantMetadata.fromPartial(object.message.updateMetadata),
       };
     }
+    if (
+      object.message?.$case === "pingReq" && object.message?.pingReq !== undefined && object.message?.pingReq !== null
+    ) {
+      message.message = { $case: "pingReq", pingReq: Ping.fromPartial(object.message.pingReq) };
+    }
     return message;
   },
 };
@@ -754,6 +786,9 @@ export const SignalResponse = {
     if (message.message?.$case === "reconnect") {
       ReconnectResponse.encode(message.message.reconnect, writer.uint32(154).fork()).ldelim();
     }
+    if (message.message?.$case === "pongResp") {
+      Pong.encode(message.message.pongResp, writer.uint32(162).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -839,6 +874,9 @@ export const SignalResponse = {
         case 19:
           message.message = { $case: "reconnect", reconnect: ReconnectResponse.decode(reader, reader.uint32()) };
           break;
+        case 20:
+          message.message = { $case: "pongResp", pongResp: Pong.decode(reader, reader.uint32()) };
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -891,6 +929,8 @@ export const SignalResponse = {
         ? { $case: "pong", pong: Number(object.pong) }
         : isSet(object.reconnect)
         ? { $case: "reconnect", reconnect: ReconnectResponse.fromJSON(object.reconnect) }
+        : isSet(object.pongResp)
+        ? { $case: "pongResp", pongResp: Pong.fromJSON(object.pongResp) }
         : undefined,
     };
   },
@@ -940,6 +980,8 @@ export const SignalResponse = {
     message.message?.$case === "pong" && (obj.pong = Math.round(message.message?.pong));
     message.message?.$case === "reconnect" &&
       (obj.reconnect = message.message?.reconnect ? ReconnectResponse.toJSON(message.message?.reconnect) : undefined);
+    message.message?.$case === "pongResp" &&
+      (obj.pongResp = message.message?.pongResp ? Pong.toJSON(message.message?.pongResp) : undefined);
     return obj;
   },
 
@@ -1064,6 +1106,13 @@ export const SignalResponse = {
     ) {
       message.message = { $case: "reconnect", reconnect: ReconnectResponse.fromPartial(object.message.reconnect) };
     }
+    if (
+      object.message?.$case === "pongResp" &&
+      object.message?.pongResp !== undefined &&
+      object.message?.pongResp !== null
+    ) {
+      message.message = { $case: "pongResp", pongResp: Pong.fromPartial(object.message.pongResp) };
+    }
     return message;
   },
 };
@@ -1626,7 +1675,13 @@ export const JoinResponse = {
 };
 
 function createBaseReconnectResponse(): ReconnectResponse {
-  return { iceServers: [], clientConfiguration: undefined };
+  return {
+    iceServers: [],
+    clientConfiguration: undefined,
+    room: undefined,
+    participant: undefined,
+    otherParticipants: [],
+  };
 }
 
 export const ReconnectResponse = {
@@ -1637,6 +1692,15 @@ export const ReconnectResponse = {
     if (message.clientConfiguration !== undefined) {
       ClientConfiguration.encode(message.clientConfiguration, writer.uint32(18).fork()).ldelim();
     }
+    if (message.room !== undefined) {
+      Room.encode(message.room, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.participant !== undefined) {
+      ParticipantInfo.encode(message.participant, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.otherParticipants) {
+      ParticipantInfo.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1653,6 +1717,15 @@ export const ReconnectResponse = {
         case 2:
           message.clientConfiguration = ClientConfiguration.decode(reader, reader.uint32());
           break;
+        case 3:
+          message.room = Room.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.participant = ParticipantInfo.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.otherParticipants.push(ParticipantInfo.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1667,6 +1740,11 @@ export const ReconnectResponse = {
       clientConfiguration: isSet(object.clientConfiguration)
         ? ClientConfiguration.fromJSON(object.clientConfiguration)
         : undefined,
+      room: isSet(object.room) ? Room.fromJSON(object.room) : undefined,
+      participant: isSet(object.participant) ? ParticipantInfo.fromJSON(object.participant) : undefined,
+      otherParticipants: Array.isArray(object?.otherParticipants)
+        ? object.otherParticipants.map((e: any) => ParticipantInfo.fromJSON(e))
+        : [],
     };
   },
 
@@ -1680,6 +1758,14 @@ export const ReconnectResponse = {
     message.clientConfiguration !== undefined && (obj.clientConfiguration = message.clientConfiguration
       ? ClientConfiguration.toJSON(message.clientConfiguration)
       : undefined);
+    message.room !== undefined && (obj.room = message.room ? Room.toJSON(message.room) : undefined);
+    message.participant !== undefined &&
+      (obj.participant = message.participant ? ParticipantInfo.toJSON(message.participant) : undefined);
+    if (message.otherParticipants) {
+      obj.otherParticipants = message.otherParticipants.map((e) => e ? ParticipantInfo.toJSON(e) : undefined);
+    } else {
+      obj.otherParticipants = [];
+    }
     return obj;
   },
 
@@ -1689,6 +1775,11 @@ export const ReconnectResponse = {
     message.clientConfiguration = (object.clientConfiguration !== undefined && object.clientConfiguration !== null)
       ? ClientConfiguration.fromPartial(object.clientConfiguration)
       : undefined;
+    message.room = (object.room !== undefined && object.room !== null) ? Room.fromPartial(object.room) : undefined;
+    message.participant = (object.participant !== undefined && object.participant !== null)
+      ? ParticipantInfo.fromPartial(object.participant)
+      : undefined;
+    message.otherParticipants = object.otherParticipants?.map((e) => ParticipantInfo.fromPartial(e)) || [];
     return message;
   },
 };
@@ -3388,6 +3479,122 @@ export const SimulateScenario = {
   },
 };
 
+function createBasePing(): Ping {
+  return { timestamp: 0, rtt: 0 };
+}
+
+export const Ping = {
+  encode(message: Ping, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.timestamp !== 0) {
+      writer.uint32(8).int64(message.timestamp);
+    }
+    if (message.rtt !== 0) {
+      writer.uint32(16).int64(message.rtt);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Ping {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePing();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.timestamp = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.rtt = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Ping {
+    return {
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      rtt: isSet(object.rtt) ? Number(object.rtt) : 0,
+    };
+  },
+
+  toJSON(message: Ping): unknown {
+    const obj: any = {};
+    message.timestamp !== undefined && (obj.timestamp = Math.round(message.timestamp));
+    message.rtt !== undefined && (obj.rtt = Math.round(message.rtt));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Ping>, I>>(object: I): Ping {
+    const message = createBasePing();
+    message.timestamp = object.timestamp ?? 0;
+    message.rtt = object.rtt ?? 0;
+    return message;
+  },
+};
+
+function createBasePong(): Pong {
+  return { lastPingTimestamp: 0, timestamp: 0 };
+}
+
+export const Pong = {
+  encode(message: Pong, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.lastPingTimestamp !== 0) {
+      writer.uint32(8).int64(message.lastPingTimestamp);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(16).int64(message.timestamp);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Pong {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePong();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.lastPingTimestamp = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.timestamp = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Pong {
+    return {
+      lastPingTimestamp: isSet(object.lastPingTimestamp) ? Number(object.lastPingTimestamp) : 0,
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+    };
+  },
+
+  toJSON(message: Pong): unknown {
+    const obj: any = {};
+    message.lastPingTimestamp !== undefined && (obj.lastPingTimestamp = Math.round(message.lastPingTimestamp));
+    message.timestamp !== undefined && (obj.timestamp = Math.round(message.timestamp));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Pong>, I>>(object: I): Pong {
+    const message = createBasePong();
+    message.lastPingTimestamp = object.lastPingTimestamp ?? 0;
+    message.timestamp = object.timestamp ?? 0;
+    return message;
+  },
+};
+
 declare var self: any | undefined;
 declare var window: any | undefined;
 declare var global: any | undefined;

package/src/room/RTCEngine.ts

@@ -9,6 +9,7 @@ import {
   DataPacket,
   DataPacket_Kind,
   DisconnectReason,
+  ReconnectReason,
   SpeakerInfo,
   TrackInfo,
   UserPacket,
@@ -305,7 +306,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     let primaryPC = this.publisher.pc;
     let secondaryPC = this.subscriber.pc;
-    if (joinResponse.subscriberPrimary) {
+    let subscriberPrimary = joinResponse.subscriberPrimary;
+    if (subscriberPrimary) {
       primaryPC = this.subscriber.pc;
       secondaryPC = this.publisher.pc;
       // in subscriber primary mode, server side opens sub data channels.
@@ -330,7 +332,13 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         if (this.pcState === PCState.Connected) {
           this.pcState = PCState.Disconnected;
 
-          this.handleDisconnect('primary peerconnection');
+          this.handleDisconnect(
+            'primary peerconnection',
+            false,
+            subscriberPrimary
+              ? ReconnectReason.REASON_SUBSCRIBER_FAILED
+              : ReconnectReason.REASON_PUBLISHER_FAILED,
+          );
         }
       }
     };
@@ -338,7 +346,13 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       log.debug(`secondary PC state changed ${secondaryPC.connectionState}`);
       // also reconnect if secondary peerconnection fails
       if (secondaryPC.connectionState === 'failed') {
-        this.handleDisconnect('secondary peerconnection');
+        this.handleDisconnect(
+          'secondary peerconnection',
+          false,
+          subscriberPrimary
+            ? ReconnectReason.REASON_PUBLISHER_FAILED
+            : ReconnectReason.REASON_SUBSCRIBER_FAILED,
+        );
       }
     };
 
@@ -405,7 +419,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     };
 
     this.client.onClose = () => {
-      this.handleDisconnect('signal');
+      this.handleDisconnect('signal', false, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
     };
 
     this.client.onLeave = (leave?: LeaveRequest) => {
@@ -676,7 +690,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
   // continues to work, we can reconnect to websocket to continue the session
   // after a number of retries, we'll close and give up permanently
-  private handleDisconnect = (connection: string, signalEvents: boolean = false) => {
+  private handleDisconnect = (
+    connection: string,
+    signalEvents: boolean = false,
+    disconnectReason?: ReconnectReason,
+  ) => {
     if (this._isClosed) {
       return;
     }
@@ -713,12 +731,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.clearReconnectTimeout();
     this.reconnectTimeout = CriticalTimers.setTimeout(
-      () => this.attemptReconnect(signalEvents),
+      () => this.attemptReconnect(signalEvents, disconnectReason),
       delay,
     );
   };
 
-  private async attemptReconnect(signalEvents: boolean = false) {
+  private async attemptReconnect(signalEvents: boolean = false, reason?: ReconnectReason) {
     if (this._isClosed) {
       return;
     }
@@ -740,7 +758,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (this.fullReconnectOnNext) {
         await this.restartConnection(signalEvents);
       } else {
-        await this.resumeConnection(signalEvents);
+        await this.resumeConnection(signalEvents, reason);
       }
       this.clearPendingReconnect();
       this.fullReconnectOnNext = false;
@@ -766,7 +784,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
 
       if (recoverable) {
-        this.handleDisconnect('reconnect', requireSignalEvents);
+        this.handleDisconnect('reconnect', requireSignalEvents, ReconnectReason.REASON_UNKOWN);
       } else {
         log.info(
           `could not recover connection after ${this.reconnectAttempts} attempts, ${
@@ -831,7 +849,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.emit(EngineEvent.Restarted, joinResponse);
   }
 
-  private async resumeConnection(emitResuming: boolean = false): Promise<void> {
+  private async resumeConnection(
+    emitResuming: boolean = false,
+    reason?: ReconnectReason,
+  ): Promise<void> {
     if (!this.url || !this.token) {
       // permanent failure, don't attempt reconnection
       throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -847,7 +868,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     try {
-      const res = await this.client.reconnect(this.url, this.token, this.participantSid);
+      const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
       if (res) {
         const rtcConfig = this.makeRTCConfiguration(res);
         this.publisher.pc.setConfiguration(rtcConfig);
@@ -1001,7 +1022,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
       const negotiationTimeout = setTimeout(() => {
         reject('negotiation timed out');
-        this.handleDisconnect('negotiation');
+        this.handleDisconnect('negotiation', false, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
       }, this.peerConnectionTimeout);
 
       const cleanup = () => {
@@ -1022,7 +1043,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
-        this.handleDisconnect('negotiation');
+        this.handleDisconnect('negotiation', false, ReconnectReason.REASON_UNKOWN);
       });
     });
   }
@@ -1060,7 +1081,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     // in case the engine is currently reconnecting, attempt a reconnect immediately after the browser state has changed to 'onLine'
     if (this.client.isReconnecting) {
       this.clearReconnectTimeout();
-      this.attemptReconnect(true);
+      this.attemptReconnect(true, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
     }
   };