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

package/lib/callkit/callkit-coordinator.js

@@ -64,6 +64,13 @@ const voice_pn_bridge_1 = require('../internal/voice-pn-bridge');
  * guidelines for proper CallKit integration.
  */
 class CallKitCoordinator {
+  claimActiveCall(callKitUUID) {
+    if (this.activeOrAnsweringCallUUID !== null && this.activeOrAnsweringCallUUID !== callKitUUID) {
+      return false;
+    }
+    this.activeOrAnsweringCallUUID = callKitUUID;
+    return true;
+  }
   static getInstance() {
     if (!CallKitCoordinator.instance) {
       CallKitCoordinator.instance = new CallKitCoordinator();
@@ -76,6 +83,7 @@ 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();
+    this.activeOrAnsweringCallUUID = null;
     // 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
@@ -187,6 +195,16 @@ class CallKitCoordinator {
         displayName || destinationNumber
       );
       if (success) {
+        if (!this.claimActiveCall(callKitUUID)) {
+          console.warn('CallKitCoordinator: Another call is already active or answering');
+          await callkit_1.default.reportCallEnded(callKitUUID, callkit_1.CallEndReason.Failed);
+          try {
+            await call.hangup();
+          } finally {
+            this.cleanupCall(callKitUUID);
+          }
+          return null;
+        }
         this.callMap.set(callKitUUID, call);
         this.setupWebRTCCallListeners(call, callKitUUID);
         call._callKitUUID = callKitUUID;
@@ -208,6 +226,10 @@ class CallKitCoordinator {
       console.warn('CallKitCoordinator: Cannot answer call - no CallKit UUID found');
       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
@@ -236,6 +258,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;
     } catch (error) {
@@ -391,6 +415,21 @@ class CallKitCoordinator {
       console.log('CallKitCoordinator: Answer action already being processed, skipping duplicate');
       return;
     }
+    if (!this.claimActiveCall(callKitUUID)) {
+      console.warn(
+        'CallKitCoordinator: Rejecting answer because another call owns the active slot'
+      );
+      await callkit_1.default.reportCallEnded(callKitUUID, callkit_1.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) {
       console.warn('CallKitCoordinator: No WebRTC call found for CallKit answer action', {
@@ -399,7 +438,10 @@ class CallKitCoordinator {
         availableWebRTCCallIds: Array.from(this.callMap.values()).map((c) => c.callId),
       });
       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;
     }
     console.log('CallKitCoordinator: Processing CallKit answer action', {
@@ -675,6 +717,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 +765,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 +773,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;
     }
   }
   /**
@@ -764,6 +832,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_1.default.reportCallEnded(callKitUUID, callkit_1.CallEndReason.Failed);
+            try {
+              await call.hangup();
+            } finally {
+              this.cleanupCall(callKitUUID);
+            }
+            break;
+          }
           this.selectCall(call);
           this.pendingPushCallUUIDs.delete(callKitUUID);
           this.autoAnswerCallUUIDs.delete(callKitUUID);
@@ -838,6 +918,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);
     // Clean up state listeners
@@ -967,6 +1050,12 @@ class CallKitCoordinator {
   actionKey(action, callKitUUID) {
     return `${action}:${this.normalizeUUID(callKitUUID)}`;
   }
+  releaseActiveCall(callKitUUID) {
+    callKitUUID = this.normalizeUUID(callKitUUID);
+    if (this.activeOrAnsweringCallUUID === callKitUUID) {
+      this.activeOrAnsweringCallUUID = null;
+    }
+  }
   selectCall(call) {
     const callKitUUID = this.getCallKitUUID(call);
     const wrapperCall = this.voipClient?.findCallByTelnyxCall(call);
@@ -1174,6 +1263,9 @@ class CallKitCoordinator {
   resetFlags() {
     console.log('CallKitCoordinator: Resetting coordinator flags');
     this.isCallFromPush = this.pendingPushCallUUIDs.size > 0;
+    if (this.callMap.size === 0) {
+      this.activeOrAnsweringCallUUID = null;
+    }
     console.log('CallKitCoordinator: ✅ Coordinator flags reset');
   }
   /**
@@ -1187,6 +1279,14 @@ class CallKitCoordinator {
     // call arrives during push notification handling.
     return this.processingCalls.size > 0 || this.isCallFromPush;
   }
+  /** @internal Exposed for deterministic single-active-call regression tests. */
+  claimActiveCallForTesting(callKitUUID) {
+    return this.claimActiveCall(callKitUUID);
+  }
+  /** @internal Exposed for deterministic single-active-call regression tests. */
+  releaseActiveCallForTesting(callKitUUID) {
+    this.releaseActiveCall(callKitUUID);
+  }
   /**
    * Check if there's currently a call from push notification being processed
    * This helps prevent disconnection during push call handling

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
    */

package/lib/internal/session/session-manager.js

@@ -56,12 +56,15 @@ exports.SessionManager = void 0;
 const rxjs_1 = require('rxjs');
 const operators_1 = require('rxjs/operators');
 const TelnyxSDK = __importStar(require('@telnyx/react-native-voice-sdk'));
-const pkg = __importStar(require('../../../package.json'));
+const sdk_identity_1 = require('../sdk-identity');
+const ice_servers_storage_1 = require('../ice-servers-storage');
+const signaling_environment_1 = require('../signaling-environment');
 const connection_state_1 = require('../../models/connection-state');
 const config_1 = require('../../models/config');
 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';
 /**
  * Manages the connection lifecycle to the Telnyx platform.
  *
@@ -69,7 +72,7 @@ const MISSED_CALL_NOTIFICATIONS_STORAGE_KEY = '@enable_missed_call_notifications
  * and automatic reconnection logic.
  */
 class SessionManager {
-  constructor() {
+  constructor(options = {}) {
     this._connectionState = new rxjs_1.BehaviorSubject(
       connection_state_1.TelnyxConnectionState.DISCONNECTED
     );
@@ -77,6 +80,7 @@ class SessionManager {
     this._disposing = false;
     this._connectionGeneration = 0;
     this._sessionId = this._generateSessionId();
+    this._defaultEnvironment = options.defaultEnvironment ?? 'production';
   }
   /**
    * Observable stream of connection state changes
@@ -254,9 +258,22 @@ class SessionManager {
         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 storedIceServers = await AsyncStorage.getItem(
+          ice_servers_storage_1.ICE_SERVERS_STORAGE_KEY
+        );
+        const iceServers = (0, ice_servers_storage_1.parseStoredIceServers)(storedIceServers);
         const useTrickleIce = storedUseTrickleIce === 'true';
         const pushWhenActive = storedPushWhenActive === 'true';
         const enableMissedCallNotifications = storedMissedCallNotifications === 'true';
+        const enableQualityMetrics = storedQualityMetrics === 'true';
+        const environment = (0, signaling_environment_1.resolveStoredEnvironment)(
+          storedEnvironment,
+          this._defaultEnvironment
+        );
         if (this._isTeardownActive()) {
           return;
         }
@@ -269,6 +286,9 @@ class SessionManager {
             useTrickleIce,
             pushWhenActive,
             enableMissedCallNotifications,
+            enableQualityMetrics,
+            environment,
+            iceServers,
           });
         }
         // Check if we have token-based authentication data
@@ -280,6 +300,9 @@ class SessionManager {
             useTrickleIce,
             pushWhenActive,
             enableMissedCallNotifications,
+            enableQualityMetrics,
+            environment,
+            iceServers,
           });
         }
         if (this._currentConfig) {
@@ -463,11 +486,15 @@ 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: sdk_identity_1.REACT_NATIVE_COMMONS_SDK_IDENTITY.name,
+          sdkVersion: sdk_identity_1.REACT_NATIVE_COMMONS_SDK_IDENTITY.version,
         };
         console.log(
           '🔧 SessionManager: Creating TelnyxRTC with credential config, logLevel:',
@@ -484,11 +511,15 @@ 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: sdk_identity_1.REACT_NATIVE_COMMONS_SDK_IDENTITY.name,
+          sdkVersion: sdk_identity_1.REACT_NATIVE_COMMONS_SDK_IDENTITY.version,
         };
         console.log(
           '🔧 SessionManager: Creating TelnyxRTC with token config, logLevel:',

package/lib/internal/signaling-environment.d.ts

@@ -0,0 +1,13 @@
+import { TelnyxEnvironment } from '../models/config';
+export declare const SIGNALING_ENVIRONMENT_STORAGE_KEY = '@telnyx_signaling_environment';
+/**
+ * Resolves the signaling environment for a stored-config restore.
+ *
+ * An explicit stored selection always wins. A missing or invalid stored value
+ * (e.g. credentials persisted by an older Commons version) falls back to the
+ * client's configured default, and only then to production.
+ */
+export declare function resolveStoredEnvironment(
+  storedEnvironment: string | null | undefined,
+  defaultEnvironment?: TelnyxEnvironment
+): TelnyxEnvironment;

package/lib/internal/signaling-environment.js

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SIGNALING_ENVIRONMENT_STORAGE_KEY = void 0;
+exports.resolveStoredEnvironment = resolveStoredEnvironment;
+exports.SIGNALING_ENVIRONMENT_STORAGE_KEY = '@telnyx_signaling_environment';
+/**
+ * Resolves the signaling environment for a stored-config restore.
+ *
+ * An explicit stored selection always wins. A missing or invalid stored value
+ * (e.g. credentials persisted by an older Commons version) falls back to the
+ * client's configured default, and only then to production.
+ */
+function resolveStoredEnvironment(storedEnvironment, defaultEnvironment) {
+  if (storedEnvironment === 'development' || storedEnvironment === 'production') {
+    return storedEnvironment;
+  }
+  return defaultEnvironment ?? 'production';
+}