@telnyx/react-voice-commons-sdk 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -1,6 +1,50 @@
 # CHANGELOG.md
 
-## Unreleased
+## [1.2.1] (2026-10-30)
+
+### Bug Fixing
+
+- Fix iOS call waiting. In 1.2.0, answering a second call failed while another call was active or still being answered, so the iOS Hold & Accept and End & Accept options did not connect the new call. Answering the same call twice is still ignored.
+- `Call.answer()` on iOS now rejects when CallKit fails to answer the call, as `hold()` and `resume()` already do. It previously resolved even though the call was not answered, so apps that await `answer()` should handle the rejection.
+
+## [1.2.0] (2026-10-28)
+
+### Enhancement
+
+- Expose call-quality metrics through `Call.qualityMetrics$`, `currentQualityMetrics`, and the exported metrics and quality-level types.
+- Add automatic active-call recovery through the Voice SDK, including signaling-health monitoring, ICE restart, RTP verification, and reconnect/reattach fallback.
+- Add `iceServers` to credential and token configurations so applications can provide custom STUN/TURN servers; omitted values use the Voice SDK's Telnyx production defaults.
+- Identify Commons signaling as `webrtc-react-native-commons` with the Commons package version while retaining per-client identity isolation and the existing User-Agent format.
+
+### Dependencies
+
+- Require `react-native-webrtc ^155.0.1` (WebRTC M155), matching the Voice SDK's media dependency. Applications must target iOS 14 or newer; the Android minimum remains API 24.
+- Require `@telnyx/react-native-voice-sdk ^1.2.0` when publishing so Commons uses the matching signaling security, call recovery, metrics, and ICE-server behavior while staying within the compatible 1.x line.
+- Remove the unused direct `expo` dependency. Commons does not require Expo,
+  so this avoids installing Expo SDK 53 alongside an application's Expo SDK.
+
+### Security
+
+- Use the Voice SDK's platform-default TLS certificate and hostname validation. On iOS, signaling uses `URLSessionWebSocketTask`; Android retains React Native's OkHttp-backed WebSocket.
+
+### Bug Fixing
+
+- Handle BYE and missed-call pushes that arrive before the incoming WebRTC call exists, dismiss the matching CallKit call, clear pending push state, and show the missed-call notification without treating the original UUID as a collision.
+- Serialize CallKit registration completion with missed-call invalidation so a delayed completion cannot restore an already-ended incoming call; PushKit completion remains exactly once.
+- Keep the active CallKit UUID claimed until WebRTC answering finishes, share concurrent answer work, and reject a second call while another call owns the answering/active slot.
+- Prevent duplicate incoming and reattached-call listeners when the same client-ready callback fires more than once during connection or reconnection.
+
+## [1.1.1] (2026-09-11)
+
+### Bug Fixing
+
+- Improve iOS CallKit audio reliability by routing activation and connected-call verification through a single idempotent recovery path.
+- Recover connected calls when CallKit owns an active play-and-record audio session but the WebRTC audio device remains disabled.
+- Prevent duplicate CallKit setup from disabling WebRTC audio after a call is already active, and harden failure handling when audio recovery does not succeed.
+
+### Dependencies
+
+- Continues to require `@telnyx/react-native-voice-sdk >= 1.1.0`; no new base Voice SDK release is required.
 
 ## [1.1.0] (2026-08-07)
 

package/TelnyxVoiceCommons.podspec

@@ -9,7 +9,7 @@ Pod::Spec.new do |s|
   s.description    = package['description']
   s.homepage       = package['homepage']
   s.license        = package['license']
-  s.platforms      = { :ios => '13.0' }
+  s.platforms      = { :ios => '14.0' }
   s.swift_version  = '5.4'
   s.author         = package['author']
   s.source         = { :git => package['repository']['url'], :tag => "#{s.version}" }
@@ -22,11 +22,11 @@ Pod::Spec.new do |s|
   s.dependency 'React-Core'
   
   # WebRTC Framework dependency
-  s.dependency 'JitsiWebRTC', '~> 124.0.0'
+  s.dependency 'JitsiWebRTC', '~> 155.0.0'
 
   # iOS Frameworks
   s.frameworks = 'CallKit', 'PushKit', 'AVFoundation'
 
   # Compiler flags for Swift
   s.compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
-end
+end

package/ios/CallKitBridge.swift

@@ -156,7 +156,11 @@ import React
                 "handle": handle,
                 "uuid": uuid.uuidString,
                 "direction": "outgoing",
-                "source": "react_native",
+                // VSDK-771 AFK review: align internal source tag with the
+                // new prefixed convention so grep-based family completeness
+                // (webrtc-react-native / webrtc-react-native-commons) is
+                // clean across the SDK. Not consumed by the wire contract.
+                "source": "webrtc-react-native",
             ]
 
             callController.request(transaction) { error in
@@ -197,7 +201,9 @@ import React
                 "handle": handle,
                 "uuid": uuid.uuidString,
                 "direction": "incoming",
-                "source": "react_native",
+                // VSDK-771 AFK review: align internal source tag with the
+                // new prefixed convention. See outgoing branch above.
+                "source": "webrtc-react-native",
                 "isCallKitRegistered": false,
             ]
 
@@ -741,6 +747,10 @@ import React
         public var callKitProvider: CXProvider?
         public var callKitController: CXCallController?
         private let stateLock = NSRecursiveLock()
+        // Keep terminal missed-call invalidation atomic with registration side effects so a
+        // delayed CallKit completion cannot restore an already-ended incoming call.
+        private let incomingRegistrationQueue = DispatchQueue(
+            label: "com.telnyx.react-voice-commons.incoming-registration")
         public lazy var activeCalls = LockedDictionary<UUID, [String: Any]>(lock: stateLock)
         public lazy var pendingAnswerActions = LockedDictionary<UUID, CXAnswerCallAction>(
             lock: stateLock)
@@ -782,6 +792,35 @@ import React
             return true
         }
 
+        @discardableResult
+        fileprivate func performIncomingRegistrationIfOwned(
+            _ callUUID: UUID,
+            token: String,
+            effects: () -> Void
+        ) -> Bool {
+            return incomingRegistrationQueue.sync {
+                guard let callData = activeCalls[callUUID],
+                    callData["incomingRegistrationToken"] as? String == token
+                else {
+                    return false
+                }
+
+                effects()
+                return true
+            }
+        }
+
+        fileprivate func invalidateIncomingRegistration(_ callUUID: UUID) {
+            incomingRegistrationQueue.sync {
+                guard var callData = activeCalls[callUUID] else {
+                    return
+                }
+
+                callData.removeValue(forKey: "incomingRegistrationToken")
+                activeCalls[callUUID] = callData
+            }
+        }
+
         private override init() {
             super.init()
             // Only setup if explicitly requested via setup() method
@@ -1064,7 +1103,36 @@ import React
             }
 
             if let activeCall = activeCalls[callUUID] {
-                guard activeCall["source"] as? String == "missed_call_push" else {
+                let activeSource = activeCall["source"] as? String
+
+                // A missed-call push normally reuses the original incoming
+                // push's call_id. End that still-ringing CallKit call and show
+                // the notification instead of treating it as a UUID collision.
+                if activeSource == "push_notification" || activeSource == "terminated_app_push"
+                    || activeSource == "push"
+                {
+                    NSLog(
+                        "TelnyxVoice: Missed call matched active incoming push UUID: \(callUUID)"
+                    )
+                    // Stop the original report callback from persisting or emitting
+                    // this call while the missed-call watchdog report is pending.
+                    invalidateIncomingRegistration(callUUID)
+                    // This is a second PushKit delivery, so report it to CallKit
+                    // with a fresh UUID before ending the original ringing call.
+                    reportAndEndWatchdogCall(
+                        callUUID: UUID(),
+                        callerName: callerName,
+                        callerNumber: callerNumber,
+                        payload: payload,
+                        source: "missed_call_matched_watchdog",
+                        endedReason: .remoteEnded
+                    ) {
+                        finishMissedCall()
+                    }
+                    return true
+                }
+
+                guard activeSource == "missed_call_push" else {
                     NSLog("TelnyxVoice: Suppressing missed call notification because UUID belongs to an active call: \(callUUID)")
                     markMissedCallProcessed(id: missedCallId)
                     reportAndEndWatchdogCall(
@@ -1723,6 +1791,7 @@ import React
 
             // Store call data manually and report to CallKit
             let isAppRunning = CallKitBridge.shared != nil
+            let registrationToken = UUID().uuidString
             callKitManager.activeCalls[callUUID] = [
                 "caller": callerName,
                 "handle": callerNumber,
@@ -1731,6 +1800,7 @@ import React
                 "direction": "incoming",
                 "source": isAppRunning ? "push_notification" : "terminated_app_push",
                 "isCallKitRegistered": false,
+                "incomingRegistrationToken": registrationToken,
             ]
 
             // Report to CallKit immediately
@@ -1742,56 +1812,68 @@ import React
             callUpdate.supportsHolding = true
 
             callKitProvider.reportNewIncomingCall(with: callUUID, update: callUpdate) { error in
-                if let error = error {
-                    let nsError = error as NSError
-                    let reason =
-                        nsError.domain == CXErrorDomainIncomingCall && nsError.code == 3
-                        ? "filteredByDoNotDisturb" : "registrationRejected"
-                    NSLog(
-                        "[TelnyxVoipPushHandler] CallKit incoming registration rejected: domain=\(nsError.domain), code=\(nsError.code), reason=\(reason)"
-                    )
-                    callKitManager.activeCalls.removeValue(forKey: callUUID)
-                    callKitManager.clearPendingPushData(for: callUUID.uuidString)
-                } else {
-                    NSLog(
-                        "[TelnyxVoipPushHandler] ✅ CallKit call reported successfully via unified path"
-                    )
-
-                    callKitManager.markCallKitRegistered(callUUID)
-                    self.storePendingVoipPush(payload.dictionaryPayload)
+                defer { completion() }
 
-                    // CRITICAL: Store the CallKit UUID for the React Native CallKitCoordinator
-                    // This allows the coordinator to find the existing CallKit call instead of creating a duplicate
-                    UserDefaults.standard.set(callUUID.uuidString, forKey: "@pending_callkit_uuid")
-                    UserDefaults.standard.synchronize()
-                    NSLog(
-                        "[TelnyxVoipPushHandler] ✅ Stored CallKit UUID for React Native coordinator: \(callUUID.uuidString)"
-                    )
-
-                    // Try to emit push received event if CallKit bridge is available
-                    if let callKitBridge = CallKitBridge.shared {
-                        let source = isAppRunning ? "push_notification" : "terminated_app_push"
-                        callKitBridge.emitCallEvent(
-                            "CallKitDidReceivePush", callUUID: callUUID,
-                            callData: [
-                                "caller": callerName,
-                                "handle": callerNumber,
-                                "payload": payload.dictionaryPayload,
-                                "uuid": callUUID.uuidString,
-                                "direction": "incoming",
-                                "source": source,
-                            ])
+                let handled = callKitManager.performIncomingRegistrationIfOwned(
+                    callUUID, token: registrationToken
+                ) {
+                    if let error = error {
+                        let nsError = error as NSError
+                        let reason =
+                            nsError.domain == CXErrorDomainIncomingCall && nsError.code == 3
+                            ? "filteredByDoNotDisturb" : "registrationRejected"
                         NSLog(
-                            "[TelnyxVoipPushHandler] ✅ Emitted CallKitDidReceivePush event to React Native"
+                            "[TelnyxVoipPushHandler] CallKit incoming registration rejected: domain=\(nsError.domain), code=\(nsError.code), reason=\(reason)"
                         )
+                        callKitManager.activeCalls.removeValue(forKey: callUUID)
+                        callKitManager.clearPendingPushData(for: callUUID.uuidString)
                     } else {
                         NSLog(
-                            "[TelnyxVoipPushHandler] ⚠️ React Native bridge not ready - event will be emitted when bridge becomes available"
+                            "[TelnyxVoipPushHandler] ✅ CallKit call reported successfully via unified path"
+                        )
+
+                        callKitManager.markCallKitRegistered(callUUID)
+                        self.storePendingVoipPush(payload.dictionaryPayload)
+
+                        // CRITICAL: Store the CallKit UUID for the React Native CallKitCoordinator
+                        // This allows the coordinator to find the existing CallKit call instead of creating a duplicate
+                        UserDefaults.standard.set(
+                            callUUID.uuidString, forKey: "@pending_callkit_uuid")
+                        UserDefaults.standard.synchronize()
+                        NSLog(
+                            "[TelnyxVoipPushHandler] ✅ Stored CallKit UUID for React Native coordinator: \(callUUID.uuidString)"
                         )
+
+                        // Try to emit push received event if CallKit bridge is available
+                        if let callKitBridge = CallKitBridge.shared {
+                            let source =
+                                isAppRunning ? "push_notification" : "terminated_app_push"
+                            callKitBridge.emitCallEvent(
+                                "CallKitDidReceivePush", callUUID: callUUID,
+                                callData: [
+                                    "caller": callerName,
+                                    "handle": callerNumber,
+                                    "payload": payload.dictionaryPayload,
+                                    "uuid": callUUID.uuidString,
+                                    "direction": "incoming",
+                                    "source": source,
+                                ])
+                            NSLog(
+                                "[TelnyxVoipPushHandler] ✅ Emitted CallKitDidReceivePush event to React Native"
+                            )
+                        } else {
+                            NSLog(
+                                "[TelnyxVoipPushHandler] ⚠️ React Native bridge not ready - event will be emitted when bridge becomes available"
+                            )
+                        }
                     }
                 }
 
-                completion()
+                if !handled {
+                    NSLog(
+                        "[TelnyxVoipPushHandler] Ignoring stale incoming registration completion for ended call: \(callUUID.uuidString)"
+                    )
+                }
             }
         }
 

package/lib/callkit/callkit-coordinator.d.ts

@@ -1,5 +1,12 @@
 import { Call } from '@telnyx/react-native-voice-sdk';
 import type { TelnyxVoipClient } from '../telnyx-voip-client';
+export type RemoteCallEndedReason = {
+  cause?: string;
+  causeCode?: number;
+  sipCode?: number;
+  sipReason?: string;
+  sipCallId?: string;
+};
 /**
  * CallKit Coordinator - Manages the proper CallKit-first flow for iOS
  *
@@ -80,6 +87,11 @@ declare class CallKitCoordinator {
    * before calling this method.
    */
   handleCallKitPushReceived(callKitUUID: string, event?: any): Promise<boolean>;
+  /** End a still-pending PushKit CallKit call after a remote hangup. */
+  handlePendingPushCallRemoteEnded(
+    callKitUUID: string,
+    reason?: RemoteCallEndedReason
+  ): Promise<boolean>;
   /**
    * Handle push notification answer - when user answers from CallKit but we don't have a WebRTC call yet
    * This is the iOS equivalent of the Android FCM handler

package/lib/callkit/callkit-coordinator.js

@@ -76,6 +76,8 @@ class CallKitCoordinator {
     // Tracks action+UUID pairs so an end action is not dropped merely because
     // an answer or held action for the same call is still completing.
     this.processingCalls = new Set();
+    // CallKit/the app owns cross-call hold and swap policy. Only serialize
+    // duplicate actions for the same UUID; held calls must not block a new answer.
     // Tracks calls that have already been ended in CallKit to prevent duplicate reports
     this.endedCalls = new Set();
     // Tracks calls that have already been reported as connected to prevent duplicate reports
@@ -675,6 +677,31 @@ class CallKitCoordinator {
       return false;
     }
   }
+  /** End a still-pending PushKit CallKit call after a remote hangup. */
+  async handlePendingPushCallRemoteEnded(callKitUUID, reason) {
+    callKitUUID = this.normalizeUUID(callKitUUID);
+    // Do not let an unrelated/stale socket BYE terminate another CallKit call.
+    // The UUID is added here only after native CallKit registration succeeds.
+    if (!this.pendingPushCallUUIDs.has(callKitUUID)) {
+      console.log('CallKitCoordinator: Ignoring remote-ended event for unknown push UUID', {
+        callKitUUID,
+        reason,
+      });
+      return false;
+    }
+    console.log('CallKitCoordinator: Ending pending push call after remote hangup', {
+      callKitUUID,
+      reason,
+    });
+    if (!this.endedCalls.has(callKitUUID)) {
+      await callkit_1.default.reportCallEnded(callKitUUID, callkit_1.CallEndReason.RemoteEnded);
+      this.endedCalls.add(callKitUUID);
+    }
+    this.cleanupCall(callKitUUID);
+    await this.clearMatchingPendingVoipPush(callKitUUID);
+    await this.checkBackgroundDisconnection();
+    return true;
+  }
   /**
    * Handle push notification answer - when user answers from CallKit but we don't have a WebRTC call yet
    * This is the iOS equivalent of the Android FCM handler
@@ -698,7 +725,7 @@ class CallKitCoordinator {
           // checkForInitialPushNotification() will run after setVoipClient()
           // and will find the push data still intact, call handleCallKitPushReceived()
           // which queues the matching auto-answer.
-          return;
+          return false;
         }
         // Queue one UUID-targeted answer. If the push is already being
         // processed, its eventual INVITE will consume this action. Otherwise
@@ -706,19 +733,20 @@ class CallKitCoordinator {
         voipClient.queueAnswerFromCallKit(callKitUUID);
         if (this.pendingPushCallUUIDs.has(callKitUUID)) {
           this.autoAnswerCallUUIDs.delete(callKitUUID);
-          return;
+          return true;
         }
-        await this.handleCallKitPushReceived(callKitUUID, event);
-        return;
+        return await this.handleCallKitPushReceived(callKitUUID, event);
       }
       // For other platforms (shouldn't happen on iOS)
       console.error('CallKitCoordinator: ❌ Unsupported platform for push notification handling');
       await callkit_1.default.reportCallEnded(callKitUUID, callkit_1.CallEndReason.Failed);
+      return false;
     } catch (error) {
       console.error('CallKitCoordinator: ❌ Error handling push notification answer:', error);
       // Report the call as failed to CallKit
       await callkit_1.default.reportCallEnded(callKitUUID, callkit_1.CallEndReason.Failed);
       this.cleanupCall(callKitUUID);
+      return false;
     }
   }
   /**

package/lib/index.d.ts

@@ -38,8 +38,11 @@ export {
   createCredentialConfig,
   createTokenConfig,
 } from './models/config';
-export type { Config, CredentialConfig, TokenConfig } from './models/config';
+export type { Config, CredentialConfig, TokenConfig, TelnyxEnvironment } from './models/config';
+export type { TelnyxIceServer } from '@telnyx/react-native-voice-sdk';
 export type { Call as TelnyxCall } from '@telnyx/react-native-voice-sdk';
+export { CallQualityLevel } from '@telnyx/react-native-voice-sdk';
+export type { CallQualityMetrics, QualityStatsRecord } from '@telnyx/react-native-voice-sdk';
 export * from './callkit';
 export { VoicePnBridge } from './internal/voice-pn-bridge';
 export { useAppReadyNotifier } from './hooks/useAppReadyNotifier';

package/lib/index.js

@@ -39,6 +39,7 @@ var __exportStar =
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.useAppReadyNotifier =
   exports.VoicePnBridge =
+  exports.CallQualityLevel =
   exports.createTokenConfig =
   exports.createCredentialConfig =
   exports.validateTokenConfig =
@@ -214,6 +215,14 @@ Object.defineProperty(exports, 'createTokenConfig', {
     return config_1.createTokenConfig;
   },
 });
+// Re-export call quality metrics types from the underlying SDK
+var react_native_voice_sdk_1 = require('@telnyx/react-native-voice-sdk');
+Object.defineProperty(exports, 'CallQualityLevel', {
+  enumerable: true,
+  get: function () {
+    return react_native_voice_sdk_1.CallQualityLevel;
+  },
+});
 // Export CallKit functionality
 __exportStar(require('./callkit'), exports);
 // Native push notification helpers

package/lib/internal/calls/call-state-controller.d.ts

@@ -122,6 +122,7 @@ export declare class CallStateController {
   private _removeClientListeners;
   private _handleTelnyxIncomingCall;
   private _handleTelnyxReattachedCall;
+  private _handleRemoteCallEnded;
   private _handleTelnyxCallStateChanged;
   private _handleTelnyxCallRemoved;
   /**

package/lib/internal/calls/call-state-controller.js

@@ -31,6 +31,19 @@ class CallStateController {
       console.log('CallStateController: Reattached call received:', telnyxCall.callId);
       this._handleIncomingCall(telnyxCall, msg, true);
     };
+    this._handleRemoteCallEnded = (callId, reason) => {
+      console.log('CallStateController: Pending push call ended remotely', {
+        callId,
+        reason,
+      });
+      // A tracked call can also reach the existing state-listener teardown path.
+      // Both paths are intentionally idempotent so pre-INVITE calls are covered too.
+      void callkit_coordinator_1.callKitCoordinator
+        .handlePendingPushCallRemoteEnded(callId, reason)
+        .catch((error) => {
+          console.error('CallStateController: Failed to end pending push CallKit call:', error);
+        });
+    };
     this._handleTelnyxCallStateChanged = (telnyxCall, state) => {
       console.log(
         'CallStateController: Call state changed from TelnyxRTC:',
@@ -184,8 +197,24 @@ class CallStateController {
    * This should be called by the session manager after client creation
    */
   initializeClientListeners() {
+    const telnyxClient = this._sessionManager.telnyxClient;
     console.log('CallStateController: initializeClientListeners called');
-    console.log('CallStateController: Current client exists:', !!this._sessionManager.telnyxClient);
+    console.log('CallStateController: Current client exists:', !!telnyxClient);
+    if (!telnyxClient) {
+      console.log('CallStateController: No telnyxClient available, skipping listener setup');
+      return;
+    }
+    // Skip redundant listener setup — SessionManager calls _onClientReady
+    // twice during connect/reconnect (once before connection, once on
+    // telnyx.client.ready event). _setupClientListeners() already
+    // removes old listeners before re-adding, so this guard skips the
+    // redundant off→on churn rather than preventing actual duplicates.
+    if (this._listenerClient === telnyxClient) {
+      console.log(
+        'CallStateController: Listeners already registered for this client instance, skipping'
+      );
+      return;
+    }
     this._setupClientListeners();
     // CallKit integration now handled by CallKitCoordinator
     console.log('CallStateController: Using CallKitCoordinator for CallKit integration');
@@ -320,6 +349,10 @@ class CallStateController {
     telnyxClient.on('telnyx.call.stateChanged', this._handleTelnyxCallStateChanged);
     // Listen for call removal events from TelnyxRTC (multi-call support)
     telnyxClient.on('telnyx.call.removed', this._handleTelnyxCallRemoved);
+    // A caller can hang up while PushKit is reconnecting the socket, before
+    // an INVITE creates a Call object. Forward that terminal event so the
+    // already-presented CallKit call is dismissed.
+    telnyxClient.on('telnyx.call.remoteEnded', this._handleRemoteCallEnded);
     console.log('CallStateController: Client listeners set up successfully');
   }
   _removeClientListeners() {
@@ -330,6 +363,7 @@ class CallStateController {
     this._listenerClient.off('telnyx.call.reattached', this._handleTelnyxReattachedCall);
     this._listenerClient.off('telnyx.call.stateChanged', this._handleTelnyxCallStateChanged);
     this._listenerClient.off('telnyx.call.removed', this._handleTelnyxCallRemoved);
+    this._listenerClient.off('telnyx.call.remoteEnded', this._handleRemoteCallEnded);
     this._listenerClient = undefined;
   }
   /**

package/lib/internal/ice-servers-storage.d.ts

@@ -0,0 +1,9 @@
+import type { TelnyxIceServer } from '@telnyx/react-native-voice-sdk';
+export declare const ICE_SERVERS_STORAGE_KEY = '@ice_servers';
+/**
+ * Parse the ICE servers persisted by a previous login. A missing, malformed,
+ * or structurally invalid value yields `undefined` (the core SDK then uses the
+ * Telnyx defaults) rather than throwing, so a bad stored list never discards
+ * otherwise valid stored authentication.
+ */
+export declare function parseStoredIceServers(stored: string | null): TelnyxIceServer[] | undefined;

package/lib/internal/ice-servers-storage.js

@@ -0,0 +1,37 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ICE_SERVERS_STORAGE_KEY = void 0;
+exports.parseStoredIceServers = parseStoredIceServers;
+exports.ICE_SERVERS_STORAGE_KEY = '@ice_servers';
+/**
+ * Parse the ICE servers persisted by a previous login. A missing, malformed,
+ * or structurally invalid value yields `undefined` (the core SDK then uses the
+ * Telnyx defaults) rather than throwing, so a bad stored list never discards
+ * otherwise valid stored authentication.
+ */
+function parseStoredIceServers(stored) {
+  if (!stored) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(stored);
+    if (Array.isArray(parsed) && parsed.length > 0 && parsed.every(isIceServer)) {
+      return parsed;
+    }
+  } catch {
+    // Fall through to the warning below.
+  }
+  console.warn('Ignoring invalid stored ICE servers; using the SDK defaults');
+  return undefined;
+}
+function isIceServer(value) {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const server = value;
+  return (
+    typeof server.urls === 'string' &&
+    (server.username === undefined || typeof server.username === 'string') &&
+    (server.credential === undefined || typeof server.credential === 'string')
+  );
+}

package/lib/internal/sdk-identity.d.ts

@@ -0,0 +1,4 @@
+export declare const REACT_NATIVE_COMMONS_SDK_IDENTITY: Readonly<{
+  name: 'webrtc-react-native-commons';
+  version: string;
+}>;

package/lib/internal/sdk-identity.js

@@ -0,0 +1,60 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.REACT_NATIVE_COMMONS_SDK_IDENTITY = void 0;
+const pkg = __importStar(require('../../package.json'));
+exports.REACT_NATIVE_COMMONS_SDK_IDENTITY = Object.freeze({
+  name: 'webrtc-react-native-commons',
+  version: pkg.version,
+});

package/lib/internal/session/session-manager.d.ts

@@ -1,7 +1,11 @@
 import { Observable } from 'rxjs';
 import * as TelnyxSDK from '@telnyx/react-native-voice-sdk';
 import { TelnyxConnectionState } from '../../models/connection-state';
-import { Config, CredentialConfig, TokenConfig } from '../../models/config';
+import { Config, CredentialConfig, TelnyxEnvironment, TokenConfig } from '../../models/config';
+export interface SessionManagerOptions {
+  /** Environment used when a config or stored restore does not specify one */
+  defaultEnvironment?: TelnyxEnvironment;
+}
 /**
  * Manages the connection lifecycle to the Telnyx platform.
  *
@@ -20,7 +24,8 @@ export declare class SessionManager {
   private _connectPromise?;
   private _onClientReady?;
   private _onDisconnect?;
-  constructor();
+  private readonly _defaultEnvironment;
+  constructor(options?: SessionManagerOptions);
   /**
    * Observable stream of connection state changes
    */