@stream-io/video-client 1.42.0 → 1.42.2

package/dist/src/StreamSfuClient.d.ts

@@ -1,5 +1,5 @@
 import { Dispatcher, IceTrickleBuffer } from './rtc';
-import { Error as SfuErrorEvent, JoinRequest, JoinResponse } from './gen/video/sfu/event/events';
+import { JoinRequest, JoinResponse } from './gen/video/sfu/event/events';
 import { ICERestartRequest, SendAnswerRequest, SendStatsRequest, SetPublisherRequest, TrackMuteState, TrackSubscriptionDetails } from './gen/video/sfu/signal_rpc/signal';
 import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
@@ -170,8 +170,3 @@ export declare class StreamSfuClient {
     private keepAlive;
     private scheduleConnectionCheck;
 }
-export declare class SfuJoinError extends Error {
-    errorEvent: SfuErrorEvent;
-    unrecoverable: boolean;
-    constructor(event: SfuErrorEvent);
-}

package/dist/src/devices/MicrophoneManager.d.ts

@@ -69,4 +69,5 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     protected doSetAudioBitrateProfile(profile: AudioBitrateProfile): void;
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;
+    private hasPermission;
 }

package/dist/src/errors/SfuJoinError.d.ts

@@ -0,0 +1,7 @@
+import { Error as SfuErrorEvent } from '../gen/video/sfu/event/events';
+export declare class SfuJoinError extends Error {
+    errorEvent: SfuErrorEvent;
+    unrecoverable: boolean;
+    constructor(event: SfuErrorEvent);
+    static isJoinErrorCode(event: SfuErrorEvent): boolean;
+}

package/dist/src/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './SfuJoinError';

package/dist/src/gen/coordinator/index.d.ts

@@ -5358,6 +5358,12 @@ export interface JoinCallRequest {
      * @memberof JoinCallRequest
      */
     migrating_from?: string;
+    /**
+     * List of SFU IDs to exclude when picking a new SFU for the participant
+     * @type {Array<string>}
+     * @memberof JoinCallRequest
+     */
+    migrating_from_list?: Array<string>;
     /**
      *
      * @type {boolean}

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -18,6 +18,7 @@ export declare abstract class BasePeerConnection {
     protected readonly state: CallState;
     protected readonly dispatcher: Dispatcher;
     protected readonly clientPublishOptions?: ClientPublishOptions;
+    protected readonly tag: string;
     protected sfuClient: StreamSfuClient;
     private onReconnectionNeeded?;
     private readonly iceRestartDelay;

package/dist/src/rtc/Dispatcher.d.ts

@@ -15,11 +15,45 @@ export type DispatchableMessage<K extends SfuEventKinds> = {
         [Key in K]: AllSfuEvents[Key];
     };
 };
+/**
+ * Determines if a given event name belongs to the category of SFU events.
+ *
+ * @param eventName the name of the event to check.
+ * @returns true if the event name is an SFU event, otherwise false.
+ */
 export declare const isSfuEvent: (eventName: SfuEventKinds | EventTypes) => eventName is SfuEventKinds;
 export declare class Dispatcher {
     private readonly logger;
     private subscribers;
+    /**
+     * Dispatch an event to all subscribers.
+     *
+     * @param message the event payload to dispatch.
+     * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+     */
     dispatch: <K extends SfuEventKinds>(message: DispatchableMessage<K>, tag?: string) => void;
-    on: <E extends keyof AllSfuEvents>(eventName: E, fn: CallEventListener<E>) => () => void;
-    off: <E extends keyof AllSfuEvents>(eventName: E, fn: CallEventListener<E>) => void;
+    /**
+     * Emit an event to a list of listeners.
+     *
+     * @param payload the event payload to emit.
+     * @param listeners the list of listeners to emit the event to.
+     */
+    emit: (payload: any, listeners?: CallEventListener<any>[]) => void;
+    /**
+     * Subscribe to an event.
+     *
+     * @param eventName the name of the event to subscribe to.
+     * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+     * @param fn the callback function to invoke when the event is emitted.
+     * @returns a function that can be called to unsubscribe from the event.
+     */
+    on: <E extends keyof AllSfuEvents>(eventName: E, tag: string, fn: CallEventListener<E>) => () => void;
+    /**
+     * Unsubscribe from an event.
+     *
+     * @param eventName the name of the event to unsubscribe from.
+     * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+     * @param fn the callback function to remove from the event listeners.
+     */
+    off: <E extends keyof AllSfuEvents>(eventName: E, tag: string, fn: CallEventListener<E>) => void;
 }

package/dist/src/types.d.ts

@@ -297,6 +297,12 @@ export type StreamRNVideoSDKGlobals = {
          */
         stop(): void;
     };
+    permissions: {
+        /**
+         * Checks whether a native device permission has been granted.
+         */
+        check(permission: 'microphone' | 'camera'): Promise<boolean>;
+    };
 };
 declare global {
     var streamRNVideoSDK: StreamRNVideoSDKGlobals | undefined;

package/index.ts

@@ -14,6 +14,7 @@ export * from './src/CallType';
 export * from './src/StreamVideoClient';
 export * from './src/StreamSfuClient';
 export * from './src/devices';
+export * from './src/errors';
 export * from './src/store';
 export * from './src/sorting';
 export * from './src/helpers/client-details';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.42.0",
+  "version": "1.42.2",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -1,4 +1,5 @@
-import { SfuJoinError, StreamSfuClient } from './StreamSfuClient';
+import { StreamSfuClient } from './StreamSfuClient';
+import { SfuJoinError } from './errors';
 import {
   BasePeerConnectionOpts,
   Dispatcher,
@@ -561,7 +562,7 @@ export class Call {
     fn: CallEventListener<E>,
   ) => {
     if (isSfuEvent(eventName)) {
-      return this.dispatcher.on(eventName, fn);
+      return this.dispatcher.on(eventName, '*', fn);
     }
 
     const offHandler = this.streamClient.on(eventName, (e) => {
@@ -589,7 +590,7 @@ export class Call {
     fn: CallEventListener<E>,
   ) => {
     if (isSfuEvent(eventName)) {
-      return this.dispatcher.off(eventName, fn);
+      return this.dispatcher.off(eventName, '*', fn);
     }
 
     // unsubscribe from the stream client event by using the 'off' reference
@@ -918,6 +919,7 @@ export class Call {
         this.logger.trace(`Joining call (${attempt})`, this.cid);
         await this.doJoin(data);
         delete joinData.migrating_from;
+        delete joinData.migrating_from_list;
         break;
       } catch (err) {
         this.logger.warn(`Failed to join call (${attempt})`, this.cid);
@@ -931,11 +933,17 @@ export class Call {
           throw err;
         }
 
+        // immediately switch to a different SFU in case of recoverable join error
+        const switchSfu =
+          err instanceof SfuJoinError &&
+          SfuJoinError.isJoinErrorCode(err.errorEvent);
+
         const sfuId = this.credentials?.server.edge_name || '';
         const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
         sfuJoinFailures.set(sfuId, failures);
-        if (failures >= 2) {
+        if (switchSfu || failures >= 2) {
           joinData.migrating_from = sfuId;
+          joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
         }
 
         if (attempt === maxJoinRetries - 1) {
@@ -1611,11 +1619,16 @@ export class Call {
 
     try {
       const currentSfu = currentSfuClient.edgeName;
-      await this.doJoin({ ...this.joinCallData, migrating_from: currentSfu });
+      await this.doJoin({
+        ...this.joinCallData,
+        migrating_from: currentSfu,
+        migrating_from_list: [currentSfu],
+      });
     } finally {
       // cleanup the migration_from field after the migration is complete or failed
       // as we don't want to keep dirty data in the join call data
       delete this.joinCallData?.migrating_from;
+      delete this.joinCallData?.migrating_from_list;
     }
 
     await this.restorePublishedTracks();
@@ -1660,6 +1673,10 @@ export class Call {
     // handles the "error" event, through which the SFU can request a reconnect
     const unregisterOnError = this.on('error', (e) => {
       const { reconnectStrategy: strategy, error } = e;
+      // SFU_FULL is a join error, and when emitted, although it specifies a
+      // `migrate` strategy, we should actually perform a REJOIN to a new SFU.
+      // This is now handled separately in the `call.join()` method.
+      if (SfuJoinError.isJoinErrorCode(e)) return;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {

package/src/StreamSfuClient.ts

@@ -14,7 +14,6 @@ import {
   SfuEventKinds,
 } from './rtc';
 import {
-  Error as SfuErrorEvent,
   JoinRequest,
   JoinResponse,
   SfuRequest,
@@ -27,10 +26,7 @@ import {
   TrackMuteState,
   TrackSubscriptionDetails,
 } from './gen/video/sfu/signal_rpc/signal';
-import {
-  ICETrickle,
-  WebsocketReconnectStrategy,
-} from './gen/video/sfu/models/models';
+import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { generateUUIDv4 } from './coordinator/connection/utils';
 import { Credentials } from './gen/coordinator';
@@ -43,6 +39,7 @@ import {
 } from './helpers/promise';
 import { getTimers } from './timers';
 import { Tracer, TraceSlice } from './stats';
+import { SfuJoinError } from './errors';
 
 export type StreamSfuClientConstructor = {
   /**
@@ -250,8 +247,8 @@ export class StreamSfuClient {
     // In that case, those events (ICE candidates) need to be buffered
     // and later added to the appropriate PeerConnection
     // once the remoteDescription is known and set.
-    this.unsubscribeIceTrickle = dispatcher.on('iceTrickle', (iceTrickle) => {
-      this.iceTrickleBuffer.push(iceTrickle);
+    this.unsubscribeIceTrickle = dispatcher.on('iceTrickle', tag, (t) => {
+      this.iceTrickleBuffer.push(t);
     });
 
     // listen to network changes to handle offline state
@@ -504,6 +501,7 @@ export class StreamSfuClient {
     const task = (this.migrationTask = promiseWithResolvers());
     const unsubscribe = this.dispatcher.on(
       'participantMigrationComplete',
+      this.tag,
       () => {
         unsubscribe();
         clearTimeout(this.migrateAwayTimeout);
@@ -541,27 +539,40 @@ export class StreamSfuClient {
     const current = this.joinResponseTask;
 
     let timeoutId: NodeJS.Timeout | undefined = undefined;
-    const unsubscribeJoinErrorEvents = this.dispatcher.on('error', (event) => {
-      const { error, reconnectStrategy } = event;
-      if (!error) return;
-      if (reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT) {
-        clearTimeout(timeoutId);
-        unsubscribe?.();
-        unsubscribeJoinErrorEvents();
-        current.reject(new SfuJoinError(event));
-      }
-    });
-    const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
+    let unsubscribeJoinResponse: (() => void) | undefined = undefined;
+    let unsubscribeJoinErrorEvents: (() => void) | undefined = undefined;
+
+    const cleanupJoinSubscriptions = () => {
       clearTimeout(timeoutId);
-      unsubscribe();
-      unsubscribeJoinErrorEvents();
-      this.keepAlive();
-      current.resolve(joinResponse);
-    });
+      timeoutId = undefined;
+      unsubscribeJoinErrorEvents?.();
+      unsubscribeJoinErrorEvents = undefined;
+      unsubscribeJoinResponse?.();
+      unsubscribeJoinResponse = undefined;
+    };
+
+    unsubscribeJoinErrorEvents = this.dispatcher.on(
+      'error',
+      this.tag,
+      (event) => {
+        if (SfuJoinError.isJoinErrorCode(event)) {
+          cleanupJoinSubscriptions();
+          current.reject(new SfuJoinError(event));
+        }
+      },
+    );
+    unsubscribeJoinResponse = this.dispatcher.on(
+      'joinResponse',
+      this.tag,
+      (joinResponse) => {
+        cleanupJoinSubscriptions();
+        this.keepAlive();
+        current.resolve(joinResponse);
+      },
+    );
 
     timeoutId = setTimeout(() => {
-      unsubscribe();
-      unsubscribeJoinErrorEvents();
+      cleanupJoinSubscriptions();
       const message = `Waiting for "joinResponse" has timed out after ${this.joinResponseTimeout}ms`;
       this.tracer?.trace('joinRequestTimeout', message);
       current.reject(new Error(message));
@@ -647,15 +658,3 @@ export class StreamSfuClient {
     }, this.unhealthyTimeoutInMs);
   };
 }
-
-export class SfuJoinError extends Error {
-  errorEvent: SfuErrorEvent;
-  unrecoverable: boolean;
-
-  constructor(event: SfuErrorEvent) {
-    super(event.error?.message || 'Join Error');
-    this.errorEvent = event;
-    this.unrecoverable =
-      event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
-  }
-}

package/src/devices/MicrophoneManager.ts

@@ -5,6 +5,7 @@ import {
   AudioDeviceManager,
   createAudioConstraints,
 } from './AudioDeviceManager';
+import { type BrowserPermissionState } from './BrowserPermission';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 import { TrackDisableMode } from './DeviceManagerState';
 import { getAudioDevices, getAudioStream } from './devices';
@@ -56,8 +57,15 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
           this.call.state.ownCapabilities$,
           this.state.selectedDevice$,
           this.state.status$,
+          this.state.browserPermissionState$,
         ]),
-        async ([callingState, ownCapabilities, deviceId, status]) => {
+        async ([
+          callingState,
+          ownCapabilities,
+          deviceId,
+          status,
+          permissionState,
+        ]) => {
           try {
             if (callingState === CallingState.LEFT) {
               await this.stopSpeakingWhileMutedDetection();
@@ -66,7 +74,8 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
             if (!this.speakingWhileMutedNotificationEnabled) return;
 
             if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
-              if (status !== 'enabled') {
+              const hasPermission = await this.hasPermission(permissionState);
+              if (hasPermission && status !== 'enabled') {
                 await this.startSpeakingWhileMutedDetection(deviceId);
               } else {
                 await this.stopSpeakingWhileMutedDetection();
@@ -407,4 +416,20 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       await soundDetectorCleanup();
     });
   }
+
+  private async hasPermission(
+    permissionState: BrowserPermissionState,
+  ): Promise<boolean> {
+    if (!isReactNative()) return permissionState === 'granted';
+
+    const nativePermissions = globalThis.streamRNVideoSDK?.permissions;
+    if (!nativePermissions) return true; // assume granted
+
+    try {
+      return await nativePermissions.check('microphone');
+    } catch (err) {
+      this.logger.warn('Failed to check permission', err);
+      return false;
+    }
+  }
 }

package/src/devices/__tests__/MicrophoneManager.test.ts

@@ -78,6 +78,9 @@ describe('MicrophoneManager', () => {
 
   beforeEach(() => {
     setupAudioContextMock();
+    vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+      of('granted'),
+    );
 
     call = new Call({
       id: '',
@@ -167,6 +170,20 @@ describe('MicrophoneManager', () => {
       expect(fn).toHaveBeenCalled();
     });
 
+    it('should not start sound detection if browser mic permission is denied', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('denied'),
+      );
+      const innerManager = new MicrophoneManager(call, 'disable-tracks');
+      // @ts-expect-error private api
+      const fn = vi.spyOn(innerManager, 'startSpeakingWhileMutedDetection');
+
+      await innerManager.enable();
+
+      await sleep(25);
+      expect(fn).not.toHaveBeenCalled();
+    });
+
     it(`should stop sound detection if mic is enabled`, async () => {
       manager.state.setSpeakingWhileMuted(true);
       manager['soundDetectorCleanup'] = async () => {};
@@ -177,6 +194,7 @@ describe('MicrophoneManager', () => {
       await withoutConcurrency(syncTag, () => Promise.resolve());
       await settled(syncTag);
 
+      await sleep(25);
       expect(manager.state.speakingWhileMuted).toBe(false);
     });
 
@@ -513,6 +531,7 @@ describe('MicrophoneManager', () => {
   });
 
   afterEach(() => {
+    vi.restoreAllMocks();
     vi.clearAllMocks();
     vi.resetModules();
   });

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -61,7 +61,21 @@ vi.mock('../../helpers/RNSpeechDetector.ts', () => {
 
 describe('MicrophoneManager React Native', () => {
   let manager: MicrophoneManager;
+  let checkPermissionMock: ReturnType<typeof vi.fn>;
   beforeEach(() => {
+    checkPermissionMock = vi.fn(async () => true);
+
+    globalThis.streamRNVideoSDK = {
+      callManager: {
+        setup: vi.fn(),
+        start: vi.fn(),
+        stop: vi.fn(),
+      },
+      permissions: {
+        check: checkPermissionMock,
+      },
+    };
+
     manager = new MicrophoneManager(
       new Call({
         id: '',
@@ -83,6 +97,30 @@ describe('MicrophoneManager React Native', () => {
     expect(manager['rnSpeechDetector']?.start).toHaveBeenCalled();
   });
 
+  it('should check native microphone permission before starting detection', async () => {
+    await manager.enable();
+    await manager.disable();
+
+    await vi.waitUntil(() => checkPermissionMock.mock.calls.length > 0, {
+      timeout: 100,
+    });
+    expect(checkPermissionMock).toHaveBeenCalledWith('microphone');
+  });
+
+  it('should not start sound detection if native microphone permission is denied', async () => {
+    checkPermissionMock.mockResolvedValue(false);
+
+    await manager.enable();
+    // @ts-expect-error - private method
+    const fn = vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
+    await manager.disable();
+
+    await vi.waitUntil(() => checkPermissionMock.mock.calls.length > 0, {
+      timeout: 100,
+    });
+    expect(fn).not.toHaveBeenCalled();
+  });
+
   it(`should stop sound detection if mic is enabled`, async () => {
     manager.state.setSpeakingWhileMuted(true);
     manager['soundDetectorCleanup'] = async () => {};
@@ -94,6 +132,9 @@ describe('MicrophoneManager React Native', () => {
     await withoutConcurrency(syncTag, () => Promise.resolve());
     await settled(syncTag);
 
+    await vi.waitUntil(() => manager.state.speakingWhileMuted === false, {
+      timeout: 100,
+    });
     expect(manager.state.speakingWhileMuted).toBe(false);
   });
 
@@ -139,6 +180,7 @@ describe('MicrophoneManager React Native', () => {
   });
 
   afterEach(() => {
+    globalThis.streamRNVideoSDK = undefined;
     vi.clearAllMocks();
     vi.resetModules();
   });

package/src/errors/SfuJoinError.ts

@@ -0,0 +1,26 @@
+import { Error as SfuErrorEvent } from '../gen/video/sfu/event/events';
+import {
+  ErrorCode,
+  WebsocketReconnectStrategy,
+} from '../gen/video/sfu/models/models';
+
+export class SfuJoinError extends Error {
+  errorEvent: SfuErrorEvent;
+  unrecoverable: boolean;
+
+  constructor(event: SfuErrorEvent) {
+    super(event.error?.message || 'Join Error');
+    this.errorEvent = event;
+    this.unrecoverable =
+      event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
+  }
+
+  static isJoinErrorCode(event: SfuErrorEvent): boolean {
+    const code = event.error?.code;
+    return (
+      code === ErrorCode.SFU_FULL ||
+      code === ErrorCode.SFU_SHUTTING_DOWN ||
+      code === ErrorCode.CALL_PARTICIPANT_LIMIT_REACHED
+    );
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1 @@
+export * from './SfuJoinError';

package/src/events/internal.ts

@@ -18,7 +18,7 @@ export const watchConnectionQualityChanged = (
   dispatcher: Dispatcher,
   state: CallState,
 ) => {
-  return dispatcher.on('connectionQualityChanged', (e) => {
+  return dispatcher.on('connectionQualityChanged', '*', (e) => {
     const { connectionQualityUpdates } = e;
     if (!connectionQualityUpdates) return;
     state.updateParticipants(
@@ -44,7 +44,7 @@ export const watchParticipantCountChanged = (
   dispatcher: Dispatcher,
   state: CallState,
 ) => {
-  return dispatcher.on('healthCheckResponse', (e) => {
+  return dispatcher.on('healthCheckResponse', '*', (e) => {
     const { participantCount } = e;
     if (participantCount) {
       state.setParticipantCount(participantCount.total);
@@ -54,7 +54,7 @@ export const watchParticipantCountChanged = (
 };
 
 export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
-  return dispatcher.on('error', (e) => {
+  return dispatcher.on('error', '*', (e) => {
     if (e.error && e.error.code !== ErrorCode.LIVE_ENDED) return;
 
     call.state.setBackstage(true);
@@ -70,7 +70,7 @@ export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
  * Watches and logs the errors reported by the currently connected SFU.
  */
 export const watchSfuErrorReports = (dispatcher: Dispatcher) => {
-  return dispatcher.on('error', (e) => {
+  return dispatcher.on('error', '*', (e) => {
     if (!e.error) return;
     const logger = videoLoggerSystem.getLogger('SfuClient');
     const { error, reconnectStrategy } = e;

package/src/events/speaker.ts

@@ -9,7 +9,7 @@ export const watchDominantSpeakerChanged = (
   dispatcher: Dispatcher,
   state: CallState,
 ) => {
-  return dispatcher.on('dominantSpeakerChanged', (e) => {
+  return dispatcher.on('dominantSpeakerChanged', '*', (e) => {
     const { sessionId } = e;
     if (sessionId === state.dominantSpeaker?.sessionId) return;
     state.setParticipants((participants) =>
@@ -41,7 +41,7 @@ export const watchAudioLevelChanged = (
   dispatcher: Dispatcher,
   state: CallState,
 ) => {
-  return dispatcher.on('audioLevelChanged', (e) => {
+  return dispatcher.on('audioLevelChanged', '*', (e) => {
     const { audioLevels } = e;
     state.updateParticipants(
       audioLevels.reduce<StreamVideoParticipantPatches>((patches, current) => {

package/src/gen/coordinator/index.ts

@@ -5362,6 +5362,12 @@ export interface JoinCallRequest {
    * @memberof JoinCallRequest
    */
   migrating_from?: string;
+  /**
+   * List of SFU IDs to exclude when picking a new SFU for the participant
+   * @type {Array<string>}
+   * @memberof JoinCallRequest
+   */
+  migrating_from_list?: Array<string>;
   /**
    *
    * @type {boolean}

package/src/rtc/BasePeerConnection.ts

@@ -27,6 +27,7 @@ export abstract class BasePeerConnection {
   protected readonly state: CallState;
   protected readonly dispatcher: Dispatcher;
   protected readonly clientPublishOptions?: ClientPublishOptions;
+  protected readonly tag: string;
   protected sfuClient: StreamSfuClient;
 
   private onReconnectionNeeded?: OnReconnectionNeeded;
@@ -67,6 +68,7 @@ export abstract class BasePeerConnection {
     this.dispatcher = dispatcher;
     this.iceRestartDelay = iceRestartDelay;
     this.clientPublishOptions = clientPublishOptions;
+    this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
     this.logger = videoLoggerSystem.getLogger(
       peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
@@ -162,7 +164,7 @@ export abstract class BasePeerConnection {
     fn: CallEventListener<E>,
   ): void => {
     this.subscriptions.push(
-      this.dispatcher.on(event, (e) => {
+      this.dispatcher.on(event, this.tag, (e) => {
         const lockKey = `pc.${this.lock}.${event}`;
         withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
           if (this.isDisposed) return;