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

package/lib/telnyx-voip-client.js

@@ -61,11 +61,14 @@ const connection_state_1 = require('./models/connection-state');
 const call_state_1 = require('./models/call-state');
 const config_1 = require('./models/config');
 const session_manager_1 = require('./internal/session/session-manager');
+const signaling_environment_1 = require('./internal/signaling-environment');
 const call_state_controller_1 = require('./internal/calls/call-state-controller');
 const voice_pn_bridge_1 = require('./internal/voice-pn-bridge');
+const ice_servers_storage_1 = require('./internal/ice-servers-storage');
 const USE_TRICKLE_ICE_STORAGE_KEY = '@use_trickle_ice';
 const PUSH_WHEN_ACTIVE_STORAGE_KEY = '@push_when_active';
 const MISSED_CALL_NOTIFICATIONS_STORAGE_KEY = '@enable_missed_call_notifications';
+const QUALITY_METRICS_STORAGE_KEY = '@enable_quality_metrics';
 const LEGACY_CALLKIT_ANSWER_KEY = '__legacy_callkit_answer__';
 /**
  * The main public interface for the react-voice-commons module.
@@ -111,10 +114,13 @@ class TelnyxVoipClient {
       enableAppStateManagement: true,
       debug: false,
       useTrickleIce: false,
+      environment: 'production',
       ...options,
     };
     // Initialize core components
-    this._sessionManager = new session_manager_1.SessionManager();
+    this._sessionManager = new session_manager_1.SessionManager({
+      defaultEnvironment: this._options.environment,
+    });
     this._callStateController = new call_state_controller_1.CallStateController(
       this._sessionManager
     );
@@ -308,6 +314,7 @@ class TelnyxVoipClient {
     const loginConfig = await this._withNativeVoipPushToken({
       ...config,
       useTrickleIce: config.useTrickleIce ?? this._options.useTrickleIce,
+      environment: config.environment ?? this._options.environment,
     });
     await voice_pn_bridge_1.VoicePnBridge.setIncomingCallRingtone(loginConfig.incomingCallRingtone);
     // Store credentials for future reconnection
@@ -335,6 +342,7 @@ class TelnyxVoipClient {
     const loginConfig = await this._withNativeVoipPushToken({
       ...config,
       useTrickleIce: config.useTrickleIce ?? this._options.useTrickleIce,
+      environment: config.environment ?? this._options.environment,
     });
     await voice_pn_bridge_1.VoicePnBridge.setIncomingCallRingtone(loginConfig.incomingCallRingtone);
     // Store token for future reconnection
@@ -362,7 +370,7 @@ class TelnyxVoipClient {
    * This method is used for auto-reconnection scenarios where the app
    * comes back to the foreground and needs to restore the connection.
    *
-   * @returns Promise<boolean> - true if reconnection was successful, false otherwise
+   * @returns Whether reconnection was successful.
    */
   async loginFromStoredConfig() {
     this._throwIfDisposed();
@@ -381,10 +389,22 @@ class TelnyxVoipClient {
       const storedMissedCallNotifications = await AsyncStorage.getItem(
         MISSED_CALL_NOTIFICATIONS_STORAGE_KEY
       );
+      const storedEnvironment = await AsyncStorage.getItem(
+        signaling_environment_1.SIGNALING_ENVIRONMENT_STORAGE_KEY
+      );
+      const storedQualityMetrics = await AsyncStorage.getItem(QUALITY_METRICS_STORAGE_KEY);
+      const iceServers = (0, ice_servers_storage_1.parseStoredIceServers)(
+        await AsyncStorage.getItem(ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY)
+      );
       const useTrickleIce =
         storedUseTrickleIce === null ? this._options.useTrickleIce : storedUseTrickleIce === 'true';
       const pushWhenActive = storedPushWhenActive === 'true';
       const enableMissedCallNotifications = storedMissedCallNotifications === 'true';
+      const enableQualityMetrics = storedQualityMetrics === 'true';
+      const environment = (0, signaling_environment_1.resolveStoredEnvironment)(
+        storedEnvironment,
+        this._options.environment
+      );
       const nativePushToken =
         react_native_1.Platform.OS === 'ios'
           ? (await voice_pn_bridge_1.VoicePnBridge.getVoipToken())?.trim()
@@ -402,6 +422,9 @@ class TelnyxVoipClient {
           useTrickleIce,
           pushWhenActive,
           enableMissedCallNotifications,
+          enableQualityMetrics,
+          environment,
+          iceServers,
         });
         if (this._options.debug) {
           console.log(
@@ -421,6 +444,9 @@ class TelnyxVoipClient {
           useTrickleIce,
           pushWhenActive,
           enableMissedCallNotifications,
+          enableQualityMetrics,
+          environment,
+          iceServers,
         });
         if (this._options.debug) {
           console.log('TelnyxVoipClient: Reconnecting with stored token');
@@ -682,6 +708,22 @@ class TelnyxVoipClient {
         MISSED_CALL_NOTIFICATIONS_STORAGE_KEY,
         String(config.enableMissedCallNotifications ?? false)
       );
+      await AsyncStorage.setItem(
+        QUALITY_METRICS_STORAGE_KEY,
+        String(config.enableQualityMetrics ?? false)
+      );
+      await AsyncStorage.setItem(
+        signaling_environment_1.SIGNALING_ENVIRONMENT_STORAGE_KEY,
+        config.environment ?? this._options.environment ?? 'production'
+      );
+      if (config.iceServers) {
+        await AsyncStorage.setItem(
+          ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY,
+          JSON.stringify(config.iceServers)
+        );
+      } else {
+        await AsyncStorage.removeItem(ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY);
+      }
       if (config.pushNotificationDeviceToken) {
         await AsyncStorage.setItem('@push_token', config.pushNotificationDeviceToken);
       }
@@ -716,6 +758,22 @@ class TelnyxVoipClient {
         MISSED_CALL_NOTIFICATIONS_STORAGE_KEY,
         String(config.enableMissedCallNotifications ?? false)
       );
+      await AsyncStorage.setItem(
+        QUALITY_METRICS_STORAGE_KEY,
+        String(config.enableQualityMetrics ?? false)
+      );
+      await AsyncStorage.setItem(
+        signaling_environment_1.SIGNALING_ENVIRONMENT_STORAGE_KEY,
+        config.environment ?? this._options.environment ?? 'production'
+      );
+      if (config.iceServers) {
+        await AsyncStorage.setItem(
+          ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY,
+          JSON.stringify(config.iceServers)
+        );
+      } else {
+        await AsyncStorage.removeItem(ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY);
+      }
       if (config.pushNotificationDeviceToken) {
         await AsyncStorage.setItem('@push_token', config.pushNotificationDeviceToken);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telnyx/react-voice-commons-sdk",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "A high-level, state-agnostic, drop-in module for the Telnyx React Native SDK that simplifies WebRTC voice calling integration",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -68,7 +68,7 @@
     "@react-native-async-storage/async-storage": "^2.1.0",
     "react": ">=19.0.0 <20.0.0",
     "react-native": ">=0.79.0 <1.0.0",
-    "react-native-webrtc": "^124.0.5"
+    "react-native-webrtc": "^155.0.1"
   },
   "peerDependenciesMeta": {
     "@react-native-async-storage/async-storage": {
@@ -86,9 +86,8 @@
   },
   "dependencies": {
     "@react-native-community/eslint-config": "^3.2.0",
-    "@telnyx/react-native-voice-sdk": ">=1.1.0",
+    "@telnyx/react-native-voice-sdk": "^1.2.0",
     "eventemitter3": "^5.0.1",
-    "expo": "~53.0.22",
     "react-native-url-polyfill": "^3.0.0",
     "react-native-voip-push-notification": "^3.3.3",
     "rxjs": "^7.8.2"

package/src/callkit/callkit-coordinator.ts

@@ -4,6 +4,14 @@ import { Call } from '@telnyx/react-native-voice-sdk';
 import { VoicePnBridge } from '../internal/voice-pn-bridge';
 import type { TelnyxVoipClient } from '../telnyx-voip-client';
 
+export type RemoteCallEndedReason = {
+  cause?: string;
+  causeCode?: number;
+  sipCode?: number;
+  sipReason?: string;
+  sipCallId?: string;
+};
+
 type PendingSwap = {
   mode: 'swap' | 'restoring' | 'rollback';
   originalActiveCallKitUUID: string;
@@ -37,6 +45,15 @@ 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.
   private processingCalls = new Set<string>();
+  private activeOrAnsweringCallUUID: string | null = null;
+
+  private claimActiveCall(callKitUUID: string): boolean {
+    if (this.activeOrAnsweringCallUUID !== null && this.activeOrAnsweringCallUUID !== callKitUUID) {
+      return false;
+    }
+    this.activeOrAnsweringCallUUID = callKitUUID;
+    return true;
+  }
 
   // Tracks calls that have already been ended in CallKit to prevent duplicate reports
   private endedCalls = new Set<string>();
@@ -184,6 +201,16 @@ class CallKitCoordinator {
       );
 
       if (success) {
+        if (!this.claimActiveCall(callKitUUID)) {
+          console.warn('CallKitCoordinator: Another call is already active or answering');
+          await CallKit.reportCallEnded(callKitUUID, CallEndReason.Failed);
+          try {
+            await call.hangup();
+          } finally {
+            this.cleanupCall(callKitUUID);
+          }
+          return null;
+        }
         this.callMap.set(callKitUUID, call);
         this.setupWebRTCCallListeners(call, callKitUUID);
         (call as any)._callKitUUID = callKitUUID;
@@ -208,6 +235,11 @@ class CallKitCoordinator {
       return false;
     }
 
+    if (!this.claimActiveCall(callKitUUID)) {
+      console.warn('CallKitCoordinator: Another call is already active or answering');
+      return false;
+    }
+
     console.log(
       'CallKitCoordinator: Answering call from UI using CallKit answer simulation',
       callKitUUID
@@ -240,6 +272,8 @@ class CallKitCoordinator {
         this.isCallFromPush = this.pendingPushCallUUIDs.size > 0;
         await this.clearMatchingPendingVoipPush(callKitUUID);
         console.log('CallKitCoordinator: CallKit answer success');
+      } else {
+        this.releaseActiveCall(callKitUUID);
       }
 
       return success;
@@ -418,6 +452,22 @@ class CallKitCoordinator {
       return;
     }
 
+    if (!this.claimActiveCall(callKitUUID)) {
+      console.warn(
+        'CallKitCoordinator: Rejecting answer because another call owns the active slot'
+      );
+      await CallKit.reportCallEnded(callKitUUID, CallEndReason.Failed);
+      const rejectedCall = this.callMap.get(callKitUUID);
+      if (rejectedCall) {
+        try {
+          await rejectedCall.hangup();
+        } finally {
+          this.cleanupCall(callKitUUID);
+        }
+      }
+      return;
+    }
+
     const call = this.callMap.get(callKitUUID);
 
     if (!call) {
@@ -428,7 +478,10 @@ class CallKitCoordinator {
       });
 
       console.log('CallKitCoordinator: No WebRTC call found, handling as push notification');
-      await this.handlePushNotificationAnswer(callKitUUID, event);
+      const queued = await this.handlePushNotificationAnswer(callKitUUID, event);
+      if (!queued) {
+        this.releaseActiveCall(callKitUUID);
+      }
       return;
     }
 
@@ -744,11 +797,44 @@ class CallKitCoordinator {
     }
   }
 
+  /** End a still-pending PushKit CallKit call after a remote hangup. */
+  async handlePendingPushCallRemoteEnded(
+    callKitUUID: string,
+    reason?: RemoteCallEndedReason
+  ): Promise<boolean> {
+    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.reportCallEnded(callKitUUID, 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
    */
-  private async handlePushNotificationAnswer(callKitUUID: string, event?: any) {
+  private async handlePushNotificationAnswer(callKitUUID: string, event?: any): Promise<boolean> {
     try {
       console.log(
         'CallKitCoordinator: Handling push notification answer for CallKit UUID:',
@@ -770,7 +856,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
@@ -779,22 +865,22 @@ 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.reportCallEnded(callKitUUID, CallEndReason.Failed);
+      return false;
     } catch (error) {
       console.error('CallKitCoordinator: ❌ Error handling push notification answer:', error);
       // Report the call as failed to CallKit
       await CallKit.reportCallEnded(callKitUUID, CallEndReason.Failed);
       this.cleanupCall(callKitUUID);
+      return false;
     }
   }
 
@@ -849,6 +935,18 @@ class CallKitCoordinator {
 
       switch (state) {
         case 'active':
+          if (!this.claimActiveCall(callKitUUID)) {
+            console.warn(
+              'CallKitCoordinator: Ending active call because another call owns the slot'
+            );
+            await CallKit.reportCallEnded(callKitUUID, CallEndReason.Failed);
+            try {
+              await call.hangup();
+            } finally {
+              this.cleanupCall(callKitUUID);
+            }
+            break;
+          }
           this.selectCall(call);
           this.pendingPushCallUUIDs.delete(callKitUUID);
           this.autoAnswerCallUUIDs.delete(callKitUUID);
@@ -927,6 +1025,9 @@ class CallKitCoordinator {
     this.connectedCalls.delete(callKitUUID);
     this.pendingPushCallUUIDs.delete(callKitUUID);
     this.autoAnswerCallUUIDs.delete(callKitUUID);
+    if (this.activeOrAnsweringCallUUID === callKitUUID) {
+      this.activeOrAnsweringCallUUID = null;
+    }
 
     // Get the call before removing it
     const call = this.callMap.get(callKitUUID);
@@ -1084,6 +1185,13 @@ class CallKitCoordinator {
     return `${action}:${this.normalizeUUID(callKitUUID)}`;
   }
 
+  private releaseActiveCall(callKitUUID: string): void {
+    callKitUUID = this.normalizeUUID(callKitUUID);
+    if (this.activeOrAnsweringCallUUID === callKitUUID) {
+      this.activeOrAnsweringCallUUID = null;
+    }
+  }
+
   private selectCall(call: Call): void {
     const callKitUUID = this.getCallKitUUID(call);
     const wrapperCall = this.voipClient?.findCallByTelnyxCall(call);
@@ -1322,6 +1430,10 @@ class CallKitCoordinator {
 
     this.isCallFromPush = this.pendingPushCallUUIDs.size > 0;
 
+    if (this.callMap.size === 0) {
+      this.activeOrAnsweringCallUUID = null;
+    }
+
     console.log('CallKitCoordinator: ✅ Coordinator flags reset');
   }
 
@@ -1337,6 +1449,16 @@ class CallKitCoordinator {
     return this.processingCalls.size > 0 || this.isCallFromPush;
   }
 
+  /** @internal Exposed for deterministic single-active-call regression tests. */
+  claimActiveCallForTesting(callKitUUID: string): boolean {
+    return this.claimActiveCall(callKitUUID);
+  }
+
+  /** @internal Exposed for deterministic single-active-call regression tests. */
+  releaseActiveCallForTesting(callKitUUID: string): void {
+    this.releaseActiveCall(callKitUUID);
+  }
+
   /**
    * Check if there's currently a call from push notification being processed
    * This helps prevent disconnection during push call handling

package/src/index.ts

@@ -47,11 +47,16 @@ 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';
 
 // Re-export useful types from the underlying SDK
 export type { Call as TelnyxCall } from '@telnyx/react-native-voice-sdk';
 
+// Re-export call quality metrics types from the underlying SDK
+export { CallQualityLevel } from '@telnyx/react-native-voice-sdk';
+export type { CallQualityMetrics, QualityStatsRecord } from '@telnyx/react-native-voice-sdk';
+
 // Export CallKit functionality
 export * from './callkit';
 

package/src/internal/calls/call-state-controller.ts

@@ -4,7 +4,7 @@ import { TelnyxRTC, Call as TelnyxCall, type CallOptions } from '@telnyx/react-n
 import { Call } from '../../models/call';
 import { TelnyxCallState } from '../../models/call-state';
 import { SessionManager } from '../session/session-manager';
-import { callKitCoordinator } from '../../callkit/callkit-coordinator';
+import { callKitCoordinator, type RemoteCallEndedReason } from '../../callkit/callkit-coordinator';
 
 export type CustomHeader = { name: string; value: string };
 export type CustomHeaders = Record<string, string> | CustomHeader[];
@@ -178,8 +178,28 @@ export class CallStateController {
    * This should be called by the session manager after client creation
    */
   initializeClientListeners(): void {
+    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
@@ -352,6 +372,11 @@ export class CallStateController {
     // 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');
   }
 
@@ -364,6 +389,7 @@ export 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;
   }
 
@@ -377,6 +403,19 @@ export class CallStateController {
     this._handleIncomingCall(telnyxCall, msg, true);
   };
 
+  private _handleRemoteCallEnded = (callId: string, reason: RemoteCallEndedReason): void => {
+    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 callKitCoordinator.handlePendingPushCallRemoteEnded(callId, reason).catch((error) => {
+      console.error('CallStateController: Failed to end pending push CallKit call:', error);
+    });
+  };
+
   private _handleTelnyxCallStateChanged = (telnyxCall: TelnyxCall, state: string): void => {
     console.log(
       'CallStateController: Call state changed from TelnyxRTC:',

package/src/internal/ice-servers-storage.ts

@@ -0,0 +1,37 @@
+import type { TelnyxIceServer } from '@telnyx/react-native-voice-sdk';
+
+export 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 function parseStoredIceServers(stored: string | null): TelnyxIceServer[] | undefined {
+  if (!stored) {
+    return undefined;
+  }
+  try {
+    const parsed: unknown = 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: unknown): value is TelnyxIceServer {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const server = value as Record<string, unknown>;
+  return (
+    typeof server.urls === 'string' &&
+    (server.username === undefined || typeof server.username === 'string') &&
+    (server.credential === undefined || typeof server.credential === 'string')
+  );
+}

package/src/internal/sdk-identity.ts

@@ -0,0 +1,6 @@
+import * as pkg from '../../package.json';
+
+export const REACT_NATIVE_COMMONS_SDK_IDENTITY = Object.freeze({
+  name: 'webrtc-react-native-commons',
+  version: pkg.version,
+});

package/src/internal/session/session-manager.ts

@@ -1,11 +1,17 @@
 import { BehaviorSubject, Observable } from 'rxjs';
 import { distinctUntilChanged } from 'rxjs/operators';
 import * as TelnyxSDK from '@telnyx/react-native-voice-sdk';
-import * as pkg from '../../../package.json';
+import { REACT_NATIVE_COMMONS_SDK_IDENTITY } from '../sdk-identity';
+import { ICE_SERVERS_STORAGE_KEY, parseStoredIceServers } from '../ice-servers-storage';
+import {
+  SIGNALING_ENVIRONMENT_STORAGE_KEY,
+  resolveStoredEnvironment,
+} from '../signaling-environment';
 import { TelnyxConnectionState } from '../../models/connection-state';
 import {
   Config,
   CredentialConfig,
+  TelnyxEnvironment,
   TokenConfig,
   isCredentialConfig,
   isTokenConfig,
@@ -14,6 +20,12 @@ import {
 const USE_TRICKLE_ICE_STORAGE_KEY = '@use_trickle_ice';
 const PUSH_WHEN_ACTIVE_STORAGE_KEY = '@push_when_active';
 const MISSED_CALL_NOTIFICATIONS_STORAGE_KEY = '@enable_missed_call_notifications';
+const QUALITY_METRICS_STORAGE_KEY = '@enable_quality_metrics';
+
+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.
@@ -35,9 +47,11 @@ export class SessionManager {
   private _connectPromise?: Promise<void>;
   private _onClientReady?: () => void;
   private _onDisconnect?: () => void;
+  private readonly _defaultEnvironment: TelnyxEnvironment;
 
-  constructor() {
+  constructor(options: SessionManagerOptions = {}) {
     this._sessionId = this._generateSessionId();
+    this._defaultEnvironment = options.defaultEnvironment ?? 'production';
   }
 
   /**
@@ -243,9 +257,15 @@ export class SessionManager {
         const storedMissedCallNotifications = await AsyncStorage.getItem(
           MISSED_CALL_NOTIFICATIONS_STORAGE_KEY
         );
+        const storedEnvironment = await AsyncStorage.getItem(SIGNALING_ENVIRONMENT_STORAGE_KEY);
+        const storedQualityMetrics = await AsyncStorage.getItem(QUALITY_METRICS_STORAGE_KEY);
+        const storedIceServers = await AsyncStorage.getItem(ICE_SERVERS_STORAGE_KEY);
+        const iceServers = parseStoredIceServers(storedIceServers);
         const useTrickleIce = storedUseTrickleIce === 'true';
         const pushWhenActive = storedPushWhenActive === 'true';
         const enableMissedCallNotifications = storedMissedCallNotifications === 'true';
+        const enableQualityMetrics = storedQualityMetrics === 'true';
+        const environment = resolveStoredEnvironment(storedEnvironment, this._defaultEnvironment);
 
         if (this._isTeardownActive()) {
           return;
@@ -260,6 +280,9 @@ export class SessionManager {
             useTrickleIce,
             pushWhenActive,
             enableMissedCallNotifications,
+            enableQualityMetrics,
+            environment,
+            iceServers,
           });
         }
         // Check if we have token-based authentication data
@@ -271,6 +294,9 @@ export class SessionManager {
             useTrickleIce,
             pushWhenActive,
             enableMissedCallNotifications,
+            enableQualityMetrics,
+            environment,
+            iceServers,
           });
         }
 
@@ -485,11 +511,15 @@ export class SessionManager {
           pushWhenActive: config.pushWhenActive,
           enableMissedCallNotifications: config.enableMissedCallNotifications ?? false,
           useTrickleIce: config.useTrickleIce,
+          environment: config.environment ?? this._defaultEnvironment,
           enableCallReports: config.enableCallReports,
+          enableQualityMetrics: config.enableQualityMetrics,
           callReportInterval: config.callReportInterval,
           callReportLogLevel: config.callReportLogLevel,
           callReportMaxLogEntries: config.callReportMaxLogEntries,
-          sdkVersion: pkg.version,
+          iceServers: config.iceServers,
+          sdkName: REACT_NATIVE_COMMONS_SDK_IDENTITY.name,
+          sdkVersion: REACT_NATIVE_COMMONS_SDK_IDENTITY.version,
         };
         console.log(
           '🔧 SessionManager: Creating TelnyxRTC with credential config, logLevel:',
@@ -506,11 +536,15 @@ export class SessionManager {
           pushWhenActive: config.pushWhenActive,
           enableMissedCallNotifications: config.enableMissedCallNotifications ?? false,
           useTrickleIce: config.useTrickleIce,
+          environment: config.environment ?? this._defaultEnvironment,
           enableCallReports: config.enableCallReports,
+          enableQualityMetrics: config.enableQualityMetrics,
           callReportInterval: config.callReportInterval,
           callReportLogLevel: config.callReportLogLevel,
           callReportMaxLogEntries: config.callReportMaxLogEntries,
-          sdkVersion: pkg.version,
+          iceServers: config.iceServers,
+          sdkName: REACT_NATIVE_COMMONS_SDK_IDENTITY.name,
+          sdkVersion: REACT_NATIVE_COMMONS_SDK_IDENTITY.version,
         };
         console.log(
           '🔧 SessionManager: Creating TelnyxRTC with token config, logLevel:',