@stream-io/video-react-native-sdk 1.40.2 → 1.42.0

package/src/hooks/push/useCallingExpWithCallingStateEffect.ts

@@ -1,6 +1,8 @@
 import { Call, CallingState, videoLoggerSystem } from '@stream-io/video-client';
 import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
 import { useEffect, useMemo } from 'react';
+import { Platform } from 'react-native';
+import { AudioDeviceModule } from '@stream-io/react-native-webrtc';
 import { filter, take } from 'rxjs/operators';
 import { getCallDisplayName } from '../../utils/internal/callingx/callingx';
 import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
@@ -190,4 +192,97 @@ export const useCallingExpWithCallingStateEffect = () => {
       subscription.remove();
     };
   }, [activeCallCid, microphone]);
+
+  // Trace CallKit audio session activation/deactivation onto the call's tracer.
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (!callingx?.isSetup || !activeCall) {
+      return;
+    }
+
+    const activateSubscription = callingx.addEventListener(
+      'didActivateAudioSession',
+      () => {
+        activeCall.tracer.trace('callingx.didActivateAudioSession', null);
+      },
+    );
+    const deactivateSubscription = callingx.addEventListener(
+      'didDeactivateAudioSession',
+      () => {
+        activeCall.tracer.trace('callingx.didDeactivateAudioSession', null);
+      },
+    );
+
+    return () => {
+      activateSubscription.remove();
+      deactivateSubscription.remove();
+    };
+  }, [activeCall]);
+
+  // Trace the iOS ADM recording state to detect silent-mic calls: the engine's
+  // input bring-up racing the CallKit audio-session activation could leave
+  // recording silently never started (mic track live, zero audio RTP sent).
+  // Samples shortly after JOINED and after every didActivateAudioSession, and
+  // traces healthy calls too so the failure rate is measurable. Detection only;
+  // the engine-availability gate in callingx owns prevention.
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (Platform.OS !== 'ios' || !callingx?.isSetup || !activeCall) {
+      return;
+    }
+
+    const timeouts = new Set<ReturnType<typeof setTimeout>>();
+
+    const traceRecordingState = (trigger: string) => {
+      if (activeCall.state.callingState !== CallingState.JOINED) return;
+      if (activeCall.microphone.state.status !== 'enabled') return;
+
+      let state;
+      try {
+        state = {
+          trigger,
+          isRecording: AudioDeviceModule.isRecording(),
+          isEngineRunning: AudioDeviceModule.isEngineRunning(),
+          isMicrophoneMuted: AudioDeviceModule.isMicrophoneMuted(),
+        };
+      } catch (error: unknown) {
+        logger.warn('failed to read the ADM recording state', error);
+        return;
+      }
+
+      activeCall.tracer.trace('ios.audioRecording.state', state);
+      if (!state.isRecording) {
+        logger.warn('mic is enabled but ADM is not recording', state);
+      }
+    };
+
+    const scheduleCheck = (trigger: string, delayMs: number) => {
+      const timeout = setTimeout(() => {
+        timeouts.delete(timeout);
+        traceRecordingState(trigger);
+      }, delayMs);
+      timeouts.add(timeout);
+    };
+
+    const joinedSubscription = activeCall.state.callingState$
+      .pipe(
+        filter((callingState) => callingState === CallingState.JOINED),
+        take(1),
+      )
+      // delayed so the normal engine bring-up can complete on its own
+      .subscribe(() => scheduleCheck('joined', 3000));
+
+    const activationSubscription = callingx.addEventListener(
+      'didActivateAudioSession',
+      // delayed so the activation-driven engine start can run first
+      () => scheduleCheck('audioSessionActivated', 1000),
+    );
+
+    return () => {
+      joinedSubscription.unsubscribe();
+      activationSubscription.remove();
+      timeouts.forEach(clearTimeout);
+      timeouts.clear();
+    };
+  }, [activeCall]);
 };

package/src/hooks/useAudioDeviceStatus.ts

@@ -0,0 +1,90 @@
+import { useEffect, useState } from 'react';
+import { callManager } from '../modules/call-manager';
+import type { AudioDevicesState } from '../modules/call-manager/types';
+
+/**
+ * Structural equality for two audio device states to avoid redundant re-renders.
+ */
+const areStatesEqual = (
+  a: AudioDevicesState | undefined,
+  b: AudioDevicesState,
+): boolean => {
+  if (!a) return false;
+  if (
+    a.selectedDeviceId !== b.selectedDeviceId ||
+    a.currentEndpointType !== b.currentEndpointType ||
+    a.devices.length !== b.devices.length
+  ) {
+    return false;
+  }
+  return a.devices.every((device, i) => {
+    const other = b.devices[i];
+    return (
+      other !== undefined &&
+      device.id === other.id &&
+      device.name === other.name &&
+      device.type === other.type
+    );
+  });
+};
+
+/**
+ * Subscribes to the current audio output device state and keeps it in sync.
+ *
+ * Works on Android, iOS, and iOS with CallKit
+ * (`@stream-io/react-native-callingx`) — the underlying source is selected
+ * automatically. Pair with `callManager.audioDevices.select(device.id)` to
+ * build a custom audio route picker.
+ *
+ * @returns the latest {@link AudioDevicesState}, or `undefined` until the
+ * initial status resolves.
+ *
+ * @example
+ * ```tsx
+ * const status = useAudioDeviceStatus();
+ * const { devices, selectedDeviceId } = status ?? {};
+ * // callManager.audioDevices.select(devices[0].id);
+ * ```
+ */
+export const useAudioDeviceStatus = (): AudioDevicesState | undefined => {
+  const [state, setState] = useState<AudioDevicesState>();
+
+  useEffect(() => {
+    let active = true;
+    let receivedUpdate = false;
+    let unsubscribe = () => {};
+
+    const applyIfChanged = (next: AudioDevicesState) => {
+      setState((prev) => (areStatesEqual(prev, next) ? prev : next));
+    };
+
+    // Live change events take precedence over the initial fetch.
+    const onChange = (next: AudioDevicesState) => {
+      if (!active) return;
+      receivedUpdate = true;
+      applyIfChanged(next);
+    };
+
+    try {
+      // Subscribe before fetching so no change between the two is missed.
+      unsubscribe = callManager.audioDevices.addChangeListener(onChange);
+      callManager.audioDevices
+        .getStatus()
+        .then((initial) => {
+          // Don't let the initial snapshot clobber newer event-driven state,
+          // and ignore it entirely after unmount.
+          if (active && !receivedUpdate) applyIfChanged(initial);
+        })
+        .catch(() => {});
+    } catch {
+      // Native/bridge error during setup — leave state undefined.
+    }
+
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, []);
+
+  return state;
+};

package/src/modules/call-manager/CallManager.ts

@@ -1,6 +1,7 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import type {
-  AudioDeviceStatus,
+  AudioDeviceEndpointType,
+  AudioDevicesState,
   IOSAudioInterruptionEvent,
   StreamInCallManagerConfig,
 } from './types';
@@ -14,11 +15,24 @@ import { videoLoggerSystem } from '@stream-io/video-client';
 const NativeManager = NativeModules.StreamInCallManager;
 const CallingxModule = getCallingxLibIfAvailable();
 const AUDIO_INTERRUPTION_EVENT = 'StreamInCallManagerAudioInterruption';
+const AUDIO_DEVICE_CHANGED_EVENT = 'onAudioDeviceChanged';
 
 const invariant = (condition: boolean, message: string) => {
   if (!condition) throw new Error(message);
 };
 
+/**
+ * Runs a fire-and-forget native call, logging instead of throwing on a bridge
+ * error so it can't crash the caller or an event-dispatch loop.
+ */
+const safeNativeCall = (label: string, fn: () => void): void => {
+  try {
+    fn();
+  } catch (error) {
+    videoLoggerSystem.getLogger('CallManager').warn(`${label} failed`, error);
+  }
+};
+
 /**
  * On Android, whether the current call is managed by Telecom (via callingx).
  * In that mode, audio routing/mode is owned by Telecom and StreamInCallManager audio methods should not be used
@@ -53,10 +67,8 @@ const getTelecomContext = ():
   return { cx: CallingxModule, callId };
 };
 
-/** Map a generic Telecom endpoint type to the SDK's endpoint display name. */
-const endpointTypeToDisplayName = (
-  type: string,
-): AudioDeviceStatus['currentEndpointType'] => {
+/** Map a generic Telecom endpoint type to the SDK's endpoint type. */
+const endpointTypeToDisplayName = (type: string): AudioDeviceEndpointType => {
   switch (type) {
     case 'earpiece':
       return 'Earpiece';
@@ -71,95 +83,136 @@ const endpointTypeToDisplayName = (
   }
 };
 
-/** Adapt a callingx endpoints snapshot to the SDK's {@link AudioDeviceStatus}. */
-const snapshotToStatus = (
+/** Adapt a callingx endpoints snapshot to the SDK's {@link AudioDevicesState}. */
+const snapshotToState = (
   snapshot: CallingxAudioSnapshot,
-): AudioDeviceStatus => ({
-  devices: snapshot.endpoints.map((e) => e.name),
+): AudioDevicesState => ({
+  // callingx endpoint ids are stable and unique — use them directly as the
+  // device id, so `select(device.id)` maps straight back to a Telecom endpoint.
+  devices: snapshot.endpoints.map((e) => ({
+    id: e.id,
+    name: e.name,
+    type: endpointTypeToDisplayName(e.type),
+  })),
+  selectedDeviceId: snapshot.currentEndpoint?.id,
   currentEndpointType: snapshot.currentEndpoint
     ? endpointTypeToDisplayName(snapshot.currentEndpoint.type)
     : 'Unknown',
-  selectedDevice: snapshot.currentEndpoint?.name ?? '',
 });
 
-class AndroidCallManager {
+/**
+ * Cross-platform audio output device picker.
+ */
+class AudioDevicesManager {
   private eventEmitter?: NativeEventEmitter;
+  private interruptionReassertSetup = false;
 
   /**
-   * Get the current audio device status.
+   * iOS + CallKit only: re-assert the user's output pick after an interruption ends.
+   *
+   * On interruption-end iOS clears the ephemeral route override (`setPreferredInput` /
+   * `overrideOutputAudioPort`) and doesn't restore it, and callingx re-applies its config
+   * only on engine-enable — not the engine-restart of interruption recovery.
    */
-  getAudioDeviceStatus = async (): Promise<AudioDeviceStatus> => {
-    invariant(Platform.OS === 'android', 'Supported only on Android');
+  private ensureInterruptionReassert = () => {
+    if (this.interruptionReassertSetup) return; // subscibed once per app lifetime
+    if (Platform.OS !== 'ios' || !CallingxModule) return;
+    this.interruptionReassertSetup = true;
+    CallingxModule.addEventListener('didAudioInterruption', (event) => {
+      if (event.phase === 'ended') {
+        safeNativeCall('reapplyAudioRoute', () =>
+          NativeManager.reapplyAudioRoute(),
+        );
+      }
+    });
+  };
+
+  /**
+   * Get the current audio device state (available devices + the selected one).
+   * Read directly from the audio session, so it works on every path.
+   */
+  getStatus = async (): Promise<AudioDevicesState> => {
+    // Android Telecom owns routing: read the endpoint snapshot from callingx.
     const tc = getTelecomContext();
     if (tc) {
       const snapshot = await tc.cx.getAvailableAudioEndpoints(tc.callId);
-      return snapshotToStatus(snapshot);
+      return snapshotToState(snapshot);
     }
     return NativeManager.getAudioDeviceStatus();
   };
 
   /**
-   * Switches the audio device to the specified endpoint.
+   * Switch the audio output to the device with the given id.
    *
-   * @param endpointName the device name.
+   * @param deviceId the stable {@link AudioDevice.id} (not the display name).
    */
-  selectAudioDevice = (endpointName: string): void => {
-    invariant(Platform.OS === 'android', 'Supported only on Android');
+  select = (deviceId: string): void => {
+    // Android Telecom owns routing: the device id is the callingx endpoint id,
+    // so route by it directly (no name lookup needed).
     const tc = getTelecomContext();
     if (tc) {
       const { cx, callId } = tc;
-      // Resolve name -> endpoint id from the current Telecom snapshot, then route via Telecom.
-      cx.getAvailableAudioEndpoints(callId)
-        .then((snapshot) => {
-          const target = snapshot.endpoints.find(
-            (e) => e.name === endpointName,
+      cx.requestAudioEndpointChange(callId, deviceId).catch((error) => {
+        videoLoggerSystem
+          .getLogger('CallManager')
+          .warn(
+            `select: failed to route to "${deviceId}" for call ${callId} via Telecom`,
+            error,
           );
-          if (target) {
-            return cx.requestAudioEndpointChange(callId, target.id);
-          }
-          return undefined;
-        })
-        .catch((error) => {
-          videoLoggerSystem
-            .getLogger('CallManager')
-            .warn(
-              `selectAudioDevice: failed to route to "${endpointName}" for call ${callId} via Telecom`,
-              error,
-            );
-        });
+      });
       return;
     }
-    NativeManager.chooseAudioDeviceEndpoint(endpointName);
+    this.ensureInterruptionReassert();
+    safeNativeCall('chooseAudioDeviceEndpoint', () =>
+      NativeManager.chooseAudioDeviceEndpoint(deviceId),
+    );
   };
 
   /**
-   * Register a listener for audio device changes.
-   * @param onChange callback to be called when the audio device changes.
+   * Register a listener for audio device changes. Returns an unsubscribe fn.
+   *
+   * @param onChange called with the latest {@link AudioDevicesState} on change.
    */
-  addAudioDeviceChangeListener = (
-    onChange: (audioDeviceStatus: AudioDeviceStatus) => void,
+  addChangeListener = (
+    onChange: (state: AudioDevicesState) => void,
   ): (() => void) => {
-    invariant(Platform.OS === 'android', 'Supported only on Android');
-    const cleanups: Array<() => void> = [];
+    let active = true;
+    const unsubscribes: Array<() => void> = [];
 
-    // Telecom (callingx) route changes.
-    if (CallingxModule?.isSetup && CallingxModule.isTelecomBacked) {
-      const sub = CallingxModule.addEventListener(
-        'didChangeAudioEndpoints',
-        (params) => onChange(snapshotToStatus(params)),
+    // callingx-owned route changes (Android Telecom + iOS CallKit). The event is
+    // signal-only, so re-read the current state — ignoring a resolve that lands
+    // after unsubscribe, and swallowing bridge rejections.
+    if (CallingxModule) {
+      const cxSub = CallingxModule.addEventListener(
+        'didChangeAudioRoute',
+        () => {
+          this.getStatus()
+            .then((state) => {
+              if (active) onChange(state);
+            })
+            .catch((error) => {
+              videoLoggerSystem
+                .getLogger('CallManager')
+                .warn('addChangeListener: getStatus failed', error);
+            });
+        },
       );
-      cleanups.push(() => sub.remove());
+      unsubscribes.push(() => cxSub.remove());
     }
 
-    // StreamInCallManager route changes (non-Telecom calls). Native
-    // suppresses these while in telecom-managed mode, and callingx emits no
-    // endpoint events for non-Telecom calls, so the two sources never overlap
-    // at runtime — safe to keep both subscribed in parallel.
-    this.eventEmitter ??= new NativeEventEmitter(NativeManager);
-    const s = this.eventEmitter.addListener('onAudioDeviceChanged', onChange);
-    cleanups.push(() => s.remove());
+    // SDK-managed route changes (non-callingx calls).
+    this.eventEmitter =
+      this.eventEmitter ?? new NativeEventEmitter(NativeManager);
+    const sdkSub = this.eventEmitter.addListener(
+      AUDIO_DEVICE_CHANGED_EVENT,
+      onChange,
+    );
+    unsubscribes.push(() => sdkSub.remove());
 
-    return () => cleanups.forEach((cleanup) => cleanup());
+    return () => {
+      active = false;
+      unsubscribes.forEach((unsubscribe) => unsubscribe());
+    };
   };
 }
 
@@ -258,7 +311,7 @@ const shouldBypassForCallKit = (): boolean => {
 };
 
 export class CallManager {
-  android = new AndroidCallManager();
+  audioDevices = new AudioDevicesManager();
   ios = new IOSCallManager();
   speaker = new SpeakerManager();
 
@@ -281,11 +334,14 @@ export class CallManager {
    */
   start = (config?: StreamInCallManagerConfig): void => {
     if (shouldBypassForCallKit()) {
-      // Forward only the passive endpoint preference; callingx reads it when
-      // CallKit drives session activation.
       if (config?.audioRole === 'communicator' && CallingxModule) {
         const type = config.deviceEndpointType ?? 'speaker';
-        CallingxModule.setDefaultAudioDeviceEndpointType(type);
+        safeNativeCall('setDefaultAudioDeviceEndpointType (callingx)', () =>
+          CallingxModule.setDefaultAudioDeviceEndpointType(type),
+        );
+        safeNativeCall('setDefaultAudioDeviceEndpointType', () =>
+          NativeManager.setDefaultAudioDeviceEndpointType(type),
+        );
       }
       videoLoggerSystem
         .getLogger('CallManager')
@@ -298,8 +354,10 @@ export class CallManager {
       // Telecom owns routing/focus; forward the sticky preference to callingx and run in
       // telecom-managed mode (StreamInCallManager keeps proximity/keep-screen-on only).
       if (config?.audioRole !== 'listener' && CallingxModule) {
-        CallingxModule.setDefaultAudioDeviceEndpointType(
-          config?.deviceEndpointType ?? 'speaker',
+        safeNativeCall('setDefaultAudioDeviceEndpointType (callingx)', () =>
+          CallingxModule.setDefaultAudioDeviceEndpointType(
+            config?.deviceEndpointType ?? 'speaker',
+          ),
         );
       }
       NativeManager.setTelecomManagedMode(true);

package/src/modules/call-manager/native-module.d.ts

@@ -1,6 +1,6 @@
 import 'react-native';
 import type { NativeModule } from 'react-native';
-import type { AudioDeviceStatus, AudioRole, DeviceEndpointType } from './types';
+import type { AudioDevicesState, AudioRole, DeviceEndpointType } from './types';
 
 export interface CallManager extends NativeModule {
   /**
@@ -33,16 +33,23 @@ export interface CallManager extends NativeModule {
   setTelecomManagedMode: (enabled: boolean) => void;
 
   /**
-   * Choose an audio device endpoint.
-   * @param endpointName - The name of the audio device endpoint to choose.
+   * Choose an audio device endpoint by its stable id.
+   * @param deviceId - The id of the audio device to choose (`AudioDevice.id`).
    */
-  chooseAudioDeviceEndpoint: (endpoint: string) => void;
+  chooseAudioDeviceEndpoint: (deviceId: string) => void;
 
   /**
-   * Get the current audio device status.
-   * @returns The audio device status.
+   * Re-applies the current audio output pick (iOS). Used to restore a Bluetooth/wired
+   * route after an interruption ends, where the ephemeral route override is lost.
+   * No-op if no explicit pick has been made.
    */
-  getAudioDeviceStatus: () => Promise<AudioDeviceStatus>;
+  reapplyAudioRoute: () => void;
+
+  /**
+   * Get the current audio device state (available devices + selected one).
+   * @returns The audio devices state.
+   */
+  getAudioDeviceStatus: () => Promise<AudioDevicesState>;
 
   /**
    * Shows the iOS audio route picker.

package/src/modules/call-manager/types.ts

@@ -6,10 +6,37 @@ export type AudioDeviceEndpointType =
   | 'Unknown'
   | (string & {});
 
-export type AudioDeviceStatus = {
-  devices: string[];
+/**
+ * A selectable audio output device.
+ *
+ * Devices are identified by a stable {@link AudioDevice.id} — never by name —
+ * so two devices that share a display name (e.g. two "AirPods Pro") never
+ * collide. On iOS the id is the `AVAudioSessionPortDescription.uid`
+ * (or the synthetic `'speaker'` / `'earpiece'` for the built-in outputs).
+ * On Android it is the `AudioDeviceInfo.id` for SDK-managed routing, or the
+ * Telecom endpoint id (a `CallEndpointCompat` identifier) when the call is
+ * Telecom-managed via callingx — stable for the lifetime of that call.
+ */
+export type AudioDevice = {
+  /** Stable, unique device identifier. Pass this to `callManager.audioDevices.select()`. */
+  id: string;
+  /** Human-readable label for display (e.g. "AirPods Pro", "Speaker"). Not stable — do not use as a key. */
+  name: string;
+  /** The kind of endpoint, useful for picking an icon. */
+  type: AudioDeviceEndpointType;
+};
+
+/**
+ * The current audio-output device state. Returned by
+ * `callManager.audioDevices.getStatus()` and the `useAudioDeviceStatus()` hook.
+ */
+export type AudioDevicesState = {
+  /** All currently available output devices. */
+  devices: AudioDevice[];
+  /** The id of the active device, matching one of `devices[].id` (when known). */
+  selectedDeviceId?: string;
+  /** The endpoint type of the active device. */
   currentEndpointType: AudioDeviceEndpointType;
-  selectedDevice: string;
 };
 
 export type AudioRole = 'communicator' | 'listener';

package/src/utils/internal/callingx/callingx.ts

@@ -5,7 +5,6 @@
 import { NativeModules, Platform } from 'react-native';
 import type { EndCallReason } from '@stream-io/react-native-callingx';
 import { getCallingxLibIfAvailable } from '../../push/libs/callingx';
-import { waitForAudioSessionActivation } from './audioSessionPromise';
 import type {
   Call,
   MemberResponse,
@@ -171,9 +170,6 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
       callDisplayName, // display name for display in call screen
       call.state.settings?.video?.enabled ?? false, // is video call?
     );
-    if (Platform.OS === 'ios') {
-      await waitForAudioSessionActivation();
-    }
   };
 
   if (
@@ -220,10 +216,6 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
       );
 
       await CallingxModule.answerIncomingCall(call.cid);
-
-      if (Platform.OS === 'ios') {
-        await waitForAudioSessionActivation();
-      }
     } catch (error) {
       logger.error(
         `Error joining incoming call in callingx: ${call.cid}`,

package/src/utils/push/setupCallingExpEvents.ts

@@ -1,10 +1,13 @@
-import { videoLoggerSystem } from '@stream-io/video-client';
+import {
+  CallingState,
+  videoLoggerSystem,
+  type StreamVideoClient,
+} from '@stream-io/video-client';
 import type { StreamVideoConfig } from '../StreamVideoRN/types';
 import {
   clearPushWSEventSubscriptions,
   processCallFromPushInBackground,
 } from './internal/utils';
-import { resolvePendingAudioSession } from '../internal/callingx/audioSessionPromise';
 import {
   getCallingxLib,
   type EventData,
@@ -50,6 +53,10 @@ export function setupCallingExpEvents(pushConfig: NonNullable<PushConfig>) {
     onDidDeactivateAudioSession,
   );
 
+  callingx.addEventListener('providerReset', (params) => {
+    onProviderReset(pushConfig)(params);
+  });
+
   //NOTE: until getInitialEvents invocation, events are delayed and won't be sent to event listeners, this is a way to make sure none of required events are missed
   //in most cases there will be no delayed answers or ends, but if so we don't want to miss any of them
   const events = callingx.getInitialEvents();
@@ -65,19 +72,50 @@ export function setupCallingExpEvents(pushConfig: NonNullable<PushConfig>) {
       onDidActivateAudioSession();
     } else if (eventName === 'didDeactivateAudioSession') {
       onDidDeactivateAudioSession();
+    } else if (eventName === 'providerReset') {
+      onProviderReset(pushConfig)(params as EventParams['providerReset']);
     }
   });
 }
 
 const onDidActivateAudioSession = () => {
   logger.debug('callingExpDidActivateAudioSession');
-  resolvePendingAudioSession();
 };
 
 const onDidDeactivateAudioSession = () => {
   logger.debug('callingExpDidDeactivateAudioSession');
 };
 
+const onProviderReset =
+  (pushConfig: PushConfig) =>
+  async ({ callCids }: EventParams['providerReset']) => {
+    logger.debug(`onProviderReset event callCids: ${callCids?.join(', ')}`);
+
+    if (!callCids?.length) {
+      return;
+    }
+
+    let videoClient: StreamVideoClient | undefined;
+    try {
+      videoClient = await pushConfig.createStreamVideoClient();
+    } catch (e) {
+      logger.error('onProviderReset: failed to resolve video client', e);
+      return;
+    }
+    if (!videoClient) {
+      return;
+    }
+
+    for (const cid of callCids) {
+      const call = videoClient.state.calls.find((c) => c.cid === cid);
+      if (call && call.state.callingState !== CallingState.LEFT) {
+        call?.leave().catch((error: unknown) => {
+          logger.error(`onProviderReset: error leaving call ${cid}`, error);
+        });
+      }
+    }
+  };
+
 const onAcceptCall =
   (pushConfig: PushConfig) =>
   ({ callId: call_cid, source }: EventParams['answerCall']) => {

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.40.2';
+export const version = '1.42.0';