@stream-io/video-client 1.42.1 → 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/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/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.1",
+  "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/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;

package/src/rtc/Dispatcher.ts

@@ -46,53 +46,95 @@ const sfuEventKinds: Record<SfuEventKinds, undefined> = {
   inboundStateNotification: undefined,
 };
 
+/**
+ * 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 const isSfuEvent = (
   eventName: SfuEventKinds | EventTypes,
 ): eventName is SfuEventKinds => {
   return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
 };
 
+type TaggedHandler = { [tag: string]: CallEventListener<any>[] | undefined };
+
 export class Dispatcher {
   private readonly logger = videoLoggerSystem.getLogger('Dispatcher');
-  private subscribers: Partial<
-    Record<SfuEventKinds, CallEventListener<any>[] | undefined>
-  > = {};
+  private subscribers: Partial<Record<SfuEventKinds, TaggedHandler>> = {};
 
+  /**
+   * 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 = '0',
+    tag: string = '*',
   ) => {
     const eventKind = message.eventPayload.oneofKind;
     if (!eventKind) return;
     const payload = message.eventPayload[eventKind];
     this.logger.debug(`Dispatching ${eventKind}, tag=${tag}`, payload);
-    const listeners = this.subscribers[eventKind];
-    if (!listeners) return;
-    for (const fn of listeners) {
+    const handlers = this.subscribers[eventKind];
+    if (!handlers) return;
+    this.emit(payload, handlers[tag]);
+    if (tag !== '*') this.emit(payload, handlers['*']);
+  };
+
+  /**
+   * 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>[] = []) => {
+    for (const listener of listeners) {
       try {
-        fn(payload);
+        listener(payload);
       } catch (e) {
         this.logger.warn('Listener failed with error', e);
       }
     }
   };
 
+  /**
+   * 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>,
   ) => {
-    (this.subscribers[eventName] ??= []).push(fn as never);
+    const bucket = (this.subscribers[eventName] ??= {} as TaggedHandler);
+    (bucket[tag] ??= []).push(fn);
     return () => {
-      this.off(eventName, fn);
+      this.off(eventName, tag, fn);
     };
   };
 
+  /**
+   * 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>,
   ) => {
-    this.subscribers[eventName] = (this.subscribers[eventName] || []).filter(
-      (f) => f !== fn,
-    );
+    const bucket = this.subscribers[eventName];
+    const listeners = bucket?.[tag];
+    if (!listeners) return;
+    bucket[tag] = listeners.filter((f) => f !== fn);
   };
 }

package/src/rtc/__tests__/Dispatcher.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest';
+import { DispatchableMessage, Dispatcher } from '../Dispatcher';
+
+describe('Dispatcher', () => {
+  it('routes events to tag listeners and wildcard listeners', () => {
+    const dispatcher = new Dispatcher();
+    const taggedListener = vi.fn();
+    const wildcardListener = vi.fn();
+
+    dispatcher.on('healthCheckResponse', 'tag-1', taggedListener);
+    dispatcher.on('healthCheckResponse', '*', wildcardListener);
+
+    const message: DispatchableMessage<'healthCheckResponse'> = {
+      eventPayload: {
+        oneofKind: 'healthCheckResponse',
+        healthCheckResponse: {} as never,
+      },
+    };
+
+    dispatcher.dispatch(message, 'tag-1');
+    expect(taggedListener).toHaveBeenCalledTimes(1);
+    expect(wildcardListener).toHaveBeenCalledTimes(1);
+
+    dispatcher.dispatch(message, 'tag-2');
+    expect(taggedListener).toHaveBeenCalledTimes(1);
+    expect(wildcardListener).toHaveBeenCalledTimes(2);
+  });
+});

package/src/rtc/__tests__/Publisher.test.ts

@@ -180,6 +180,7 @@ describe('Publisher', () => {
             },
           },
         }) as DispatchableMessage<'changePublishQuality'>,
+        'test',
       );
       expect(publisher['changePublishQuality']).toHaveBeenCalled();
     });
@@ -193,6 +194,7 @@ describe('Publisher', () => {
             changePublishOptions: { publishOptions: [], reason: 'test' },
           },
         }) as DispatchableMessage<'changePublishOptions'>,
+        'test',
       );
       expect(publisher['syncPublishOptions']).toHaveBeenCalled();
     });
@@ -210,6 +212,7 @@ describe('Publisher', () => {
             },
           },
         }) as DispatchableMessage<'iceRestart'>,
+        'test',
       );
       expect(publisher.restartIce).toHaveBeenCalled();
     });

package/src/rtc/__tests__/Subscriber.test.ts

@@ -36,7 +36,7 @@ describe('Subscriber', () => {
       sessionId: 'sessionId',
       streamClient: new StreamClient('abc'),
       cid: 'test:123',
-      tag: 'logTag',
+      tag: 'test',
       credentials: {
         server: {
           url: 'https://getstream.io/',
@@ -255,6 +255,7 @@ describe('Subscriber', () => {
             subscriberOffer,
           },
         }) as DispatchableMessage<'subscriberOffer'>,
+        'test',
       );
 
       // @ts-expect-error - private method