@webex/plugin-meetings 3.0.0-test.1 → 3.1.0

package/src/meeting/request.ts

@@ -103,6 +103,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.locale,
    * @param {Array} options.deviceCapabilities
    * @param {boolean} options.liveAnnotationSupported
+   * @param {String} options.alias
    * @returns {Promise}
    */
   async joinMeeting(options: {
@@ -122,11 +123,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     meetingNumber: any;
     permissionToken: any;
     preferTranscoding: any;
+    reachability: any;
     breakoutsSupported: boolean;
     locale?: string;
     deviceCapabilities?: Array<string>;
     liveAnnotationSupported: boolean;
     ipVersion?: IP_VERSION;
+    alias?: string;
   }) {
     const {
       asResourceOccupant,
@@ -143,12 +146,14 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       pin,
       moveToResource,
       roapMessage,
+      reachability,
       preferTranscoding,
       breakoutsSupported,
       locale,
       deviceCapabilities = [],
       liveAnnotationSupported,
       ipVersion,
+      alias,
     } = options;
 
     LoggerProxy.logger.info('Meeting:request#joinMeeting --> Joining a meeting', correlationId);
@@ -178,6 +183,10 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     };
 
+    if (alias) {
+      body.alias = alias;
+    }
+
     if (breakoutsSupported) {
       deviceCapabilities.push(BREAKOUTS.BREAKOUTS_SUPPORTED);
     }
@@ -260,8 +269,15 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       };
     }
 
-    if (roapMessage) {
-      body.localMedias = roapMessage.localMedias;
+    if (roapMessage || reachability) {
+      body.localMedias = [
+        {
+          localSdp: JSON.stringify({
+            roapMessage,
+            reachability,
+          }),
+        },
+      ];
     }
 
     /// @ts-ignore

package/src/meeting/util.ts

@@ -149,6 +149,7 @@ const MeetingUtil = {
         locusUrl: meeting.locusUrl,
         locusClusterUrl: meeting.meetingInfo?.locusClusterUrl,
         correlationId: meeting.correlationId,
+        reachability: options.reachability,
         roapMessage: options.roapMessage,
         permissionToken: meeting.permissionToken,
         resourceId: options.resourceId || null,
@@ -202,7 +203,11 @@ const MeetingUtil = {
         meeting.reconnectionManager.cleanUp();
       })
       .then(() => meeting.stopKeepAlive())
-      .then(() => meeting.updateLLMConnection());
+      .then(() => {
+        if (meeting.config?.enableAutomaticLLM) {
+          meeting.updateLLMConnection();
+        }
+      });
   },
 
   disconnectPhoneAudio: (meeting, phoneUrl) => {

package/src/meeting/voicea-meeting.ts

@@ -0,0 +1,122 @@
+export const getSpeaker = (members, csis = []) =>
+  Object.values(members).find((member: any) => {
+    const memberCSIs = member.participant.status.csis ?? [];
+
+    return csis.some((csi) => memberCSIs.includes(csi));
+  });
+
+export const getSpeakerFromProxyOrStore = ({csisKey, meetingMembers, transcriptData}) => {
+  let speaker = {
+    speakerId: '',
+    name: '',
+  };
+
+  let needsCaching = false;
+
+  if (csisKey && transcriptData.speakerProxy[csisKey]) {
+    speaker = transcriptData.speakerProxy[csisKey];
+
+    return {speaker, needsCaching};
+  }
+
+  const meetingMember: any = getSpeaker(meetingMembers, [csisKey]);
+
+  speaker = {
+    speakerId: meetingMember?.participant.person.id ?? '',
+    name: meetingMember?.participant.person.name ?? '',
+  };
+
+  needsCaching = true;
+
+  return {speaker, needsCaching};
+};
+
+export const processNewCaptions = ({data, meeting}) => {
+  const {transcriptId} = data;
+  const transcriptData = meeting.transcription;
+
+  if (data.isFinal) {
+    transcriptData.interimCaptions[transcriptId].forEach((interimId) => {
+      const interimTranscriptIndex = transcriptData.captions.findIndex(
+        (transcript) => transcript.id === interimId
+      );
+
+      if (interimTranscriptIndex !== -1) {
+        transcriptData.captions.splice(interimTranscriptIndex, 1);
+      }
+    });
+    delete transcriptData.interimCaptions[transcriptId];
+    const csisKey = data.transcript?.csis[0];
+
+    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
+      meetingMembers: meeting.members.membersCollection.members,
+      transcriptData,
+      csisKey,
+    });
+
+    if (needsCaching) {
+      transcriptData.speakerProxy[csisKey] = speaker;
+    }
+    const captionData = {
+      id: transcriptId,
+      isFinal: data.isFinal,
+      translations: data.translations,
+      text: data.transcript?.text,
+      currentSpokenLanguage: data.transcript?.transcript_language_code,
+      timestamp: data.timestamp,
+      speaker,
+    };
+    transcriptData.captions.push(captionData);
+  }
+  const {transcripts = []} = data;
+  const transcriptsPerCsis = new Map();
+
+  for (const transcript of transcripts) {
+    const {
+      text,
+      transcript_language_code: currentSpokenLanguage,
+      csis: [csisMember],
+    } = transcript;
+
+    const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`.trim();
+
+    // eslint-disable-next-line camelcase
+    transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
+  }
+  const interimTranscriptionIds = [];
+
+  for (const [key, value] of transcriptsPerCsis) {
+    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
+      meetingMembers: meeting.members.membersCollection.members,
+      transcriptData,
+      csisKey: key,
+    });
+
+    if (needsCaching) {
+      transcriptData.speakerProxy[key] = speaker;
+    }
+    const {speakerId} = speaker;
+    const interimId = `${transcriptId}_${speakerId}`;
+    const captionData = {
+      id: interimId,
+      isFinal: data.isFinal,
+      translations: value.translations,
+      text: value.text,
+      currentCaptionLanguage: value.currentSpokenLanguage,
+      timestamp: value?.timestamp,
+      speaker,
+    };
+
+    const interimTranscriptIndex = transcriptData.captions.findIndex(
+      (transcript) => transcript.id === interimId
+    );
+
+    if (interimTranscriptIndex !== -1) {
+      transcriptData.captions.splice(interimTranscriptIndex, 1);
+    }
+
+    interimTranscriptionIds.push(interimId);
+    transcriptData.captions.push(captionData);
+  }
+  transcriptData.interimCaptions[transcriptId] = interimTranscriptionIds;
+};

package/src/meeting-info/meeting-info-v2.ts

@@ -204,22 +204,16 @@ export default class MeetingInfoV2 {
       return invitees;
     };
 
-    return this.webex.internal.conversation
-      .get({url: conversationUrl}, {includeParticipants: true, disableTransform: true})
-      .then((conversation) => {
-        const body: {
-          title: string;
-          spaceUrl: string;
-          keyUrl: string;
-          kroUrl: string;
-          invitees: any[];
-          installedOrgID?: string;
-        } = {
+    return this.webex
+      .request({uri: conversationUrl, qs: {includeParticipants: true}, disableTransform: true})
+      .then(({body: conversation}) => {
+        const body = {
           title: conversation.displayName,
           spaceUrl: conversation.url,
           keyUrl: conversation.encryptionKeyUrl,
           kroUrl: conversation.kmsResourceObjectUrl,
           invitees: getInvitees(conversation.participants?.items),
+          installedOrgID,
         };
 
         if (installedOrgID) {

package/src/meeting-info/util.ts

@@ -1,13 +1,12 @@
 import url from 'url';
 
 import btoa from 'btoa';
-import {
-  // @ts-ignore
-  deconstructHydraId,
-} from '@webex/common';
+// @ts-ignore
+import {deconstructHydraId} from '@webex/common';
 
 import ParameterError from '../common/errors/parameter';
 import LoggerProxy from '../common/logs/logger-proxy';
+
 import {
   _SIP_URI_,
   _PERSONAL_ROOM_,
@@ -221,12 +220,16 @@ MeetingInfoUtil.generateOptions = async (from) => {
     try {
       await webex.internal.services.waitForCatalog('postauth');
 
-      const conversationUrl = webex.internal.conversation.getUrlFromClusterId({
-        cluster: hydraId.cluster,
-        id: hydraId.destination,
-      });
+      const serviceUrl = webex.internal.services.getServiceUrlFromClusterId(
+        {
+          cluster: hydraId.cluster,
+        },
+        webex
+      );
 
-      options.destination = conversationUrl;
+      options.destination = hydraId.destination
+        ? `${serviceUrl}/conversations/${hydraId.destination}`
+        : serviceUrl;
     } catch (e) {
       LoggerProxy.logger.error(`Meeting-info:util#generateOptions --> ${e}`);
       throw e;

package/src/meeting-info/utilv2.ts

@@ -1,9 +1,7 @@
 import url from 'url';
 
-import {
-  // @ts-ignore
-  deconstructHydraId,
-} from '@webex/common';
+// @ts-ignore
+import {deconstructHydraId} from '@webex/common';
 
 import {
   _SIP_URI_,
@@ -21,6 +19,8 @@ import {
   JOIN,
   MEET,
   MEET_M,
+  MEET_CISCO,
+  MEET_CO,
   HTTPS_PROTOCOL,
   UUID_REG,
   VALID_EMAIL_ADDRESS,
@@ -68,6 +68,8 @@ MeetingInfoUtil.isMeetingLink = (value: string) => {
     parsedUrl.pathname &&
     (parsedUrl.pathname.includes(`/${MEET}`) ||
       parsedUrl.pathname.includes(`/${MEET_M}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CISCO}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CO}`) ||
       parsedUrl.pathname.includes(`/${JOIN}`));
 
   return hostNameBool && pathNameBool;
@@ -162,7 +164,13 @@ MeetingInfoUtil.getDestinationType = async (from) => {
     };
   }
   const options: any = {};
-  const hydraId = MeetingInfoUtil.getHydraId(destination);
+  let hydraId;
+
+  if (webex && webex.config && webex.config.meetings && webex.config.meetings.disableHydraId) {
+    hydraId = null;
+  } else {
+    hydraId = MeetingInfoUtil.getHydraId(destination);
+  }
 
   if (MeetingInfoUtil.isMeetingLink(destination)) {
     LoggerProxy.logger.warn(
@@ -180,19 +188,21 @@ MeetingInfoUtil.getDestinationType = async (from) => {
   } else if (MeetingInfoUtil.isConversationUrl(destination, webex)) {
     options.type = _CONVERSATION_URL_;
     options.destination = destination;
-  } else if (hydraId.people) {
+  } else if (hydraId && hydraId.people) {
     options.type = _SIP_URI_;
 
-    return MeetingInfoUtil.getSipUriFromHydraPersonId(hydraId.destination, webex).then((res) => {
-      options.destination = res;
+    return MeetingInfoUtil.getSipUriFromHydraPersonId(hydraId && hydraId.destination, webex).then(
+      (res) => {
+        options.destination = res;
 
-      // Since hydra person ids require a unique case in which they are
-      // entirely converted to a SIP URI, we need to set a flag for detecting
-      // this type of destination.
-      options.wasHydraPerson = true;
+        // Since hydra person ids require a unique case in which they are
+        // entirely converted to a SIP URI, we need to set a flag for detecting
+        // this type of destination.
+        options.wasHydraPerson = true;
 
-      return Promise.resolve(options);
-    });
+        return Promise.resolve(options);
+      }
+    );
   } else if (hydraId.room) {
     LoggerProxy.logger.error(
       `Meeting-info:util#getDestinationType --> Using the space ID as a destination is no longer supported. Please refer to the [migration guide](https://github.com/webex/webex-js-sdk/wiki/Migration-to-Unified-Space-Meetings) to migrate to use the meeting ID or SIP address.`
@@ -282,8 +292,9 @@ MeetingInfoUtil.getRequestBody = (options: {type: string; destination: object} |
 MeetingInfoUtil.getWebexSite = (uri: string) => {
   const exceptedDomains = ['meet.webex.com', 'meetup.webex.com', 'ciscospark.com'];
   const site = uri?.match(/.+@([^.]+\.[^.]+\.[^.]+)$/)?.[1];
+  const isExceptedDomain = !!site && exceptedDomains.some((domain) => site.includes(domain));
 
-  return exceptedDomains.includes(site) ? null : site;
+  return isExceptedDomain ? null : site;
 };
 
 /**

package/src/meetings/index.ts

@@ -717,6 +717,24 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
+  /**
+   * API to toggle TLS reachability, needs to be called before webex.meetings.register()
+   * @param {Boolean} newValue
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
+  private _toggleTlsReachability(newValue: boolean) {
+    if (typeof newValue !== 'boolean') {
+      return;
+    }
+    // @ts-ignore
+    if (this.config.experimental.enableTlsReachability !== newValue) {
+      // @ts-ignore
+      this.config.experimental.enableTlsReachability = newValue;
+    }
+  }
+
   /**
    * Explicitly sets up the meetings plugin by registering
    * the device, connecting to mercury, and listening for locus events.

package/src/member/index.ts

@@ -268,7 +268,6 @@ export default class Member {
       audio: null,
       video: null,
     };
-
     // TODO: more participant types
     // such as native client, web client, is a device, what type of phone, etc
     this.processParticipant(participant);

package/src/multistream/mediaRequestManager.ts

@@ -8,10 +8,10 @@ import {
   H264Codec,
   getRecommendedMaxBitrateForFrameSize,
   RecommendedOpusBitrates,
+  NamedMediaGroup,
 } from '@webex/internal-media-core';
 import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 
-import {NamedMediaGroup} from '@webex/json-multistream';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';

package/src/multistream/remoteMediaGroup.ts

@@ -2,7 +2,7 @@
 /* eslint-disable require-jsdoc */
 /* eslint-disable import/prefer-default-export */
 import {forEach} from 'lodash';
-import {NamedMediaGroup} from '@webex/json-multistream';
+import {NamedMediaGroup} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {getMaxFs, RemoteMedia, RemoteVideoResolution} from './remoteMedia';

package/src/multistream/remoteMediaManager.ts

@@ -1,8 +1,7 @@
 /* eslint-disable valid-jsdoc */
 import {cloneDeep, forEach, remove} from 'lodash';
 import {EventMap} from 'typed-emitter';
-import {MediaType} from '@webex/internal-media-core';
-import {NamedMediaGroup} from '@webex/json-multistream';
+import {MediaType, NamedMediaGroup} from '@webex/internal-media-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';

package/src/multistream/sendSlotManager.ts

@@ -3,10 +3,9 @@ import {
   MediaType,
   LocalStream,
   MultistreamRoapMediaConnection,
+  NamedMediaGroup,
 } from '@webex/internal-media-core';
 
-import {NamedMediaGroup} from '@webex/json-multistream';
-
 export default class SendSlotManager {
   private readonly slots: Map<MediaType, SendSlot> = new Map();
   private readonly LoggerProxy: any;

package/src/reachability/clusterReachability.ts

@@ -2,7 +2,7 @@ import {Defer} from '@webex/common';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClusterNode} from './request';
-import {convertStunUrlToTurn} from './util';
+import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 
 import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
 
@@ -29,6 +29,7 @@ export type ClusterReachabilityResult = {
 export class ClusterReachability {
   private numUdpUrls: number;
   private numTcpUrls: number;
+  private numXTlsUrls: number;
   private result: ClusterReachabilityResult;
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
@@ -46,6 +47,7 @@ export class ClusterReachability {
     this.isVideoMesh = clusterInfo.isVideoMesh;
     this.numUdpUrls = clusterInfo.udp.length;
     this.numTcpUrls = clusterInfo.tcp.length;
+    this.numXTlsUrls = clusterInfo.xtls.length;
 
     this.pc = this.createPeerConnection(clusterInfo);
 
@@ -94,8 +96,16 @@ export class ClusterReachability {
       };
     });
 
+    const turnTlsIceServers = cluster.xtls.map((urlString: string) => {
+      return {
+        username: 'webexturnreachuser',
+        credential: 'webexturnreachpwd',
+        urls: [convertStunUrlToTurnTls(urlString)],
+      };
+    });
+
     return {
-      iceServers: [...udpIceServers, ...tcpIceServers],
+      iceServers: [...udpIceServers, ...tcpIceServers, ...turnTlsIceServers],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
     };
@@ -194,7 +204,7 @@ export class ClusterReachability {
    * @returns {boolean} true if we have all results, false otherwise
    */
   private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp'].every(
+    return ['udp', 'tcp', 'xtls'].every(
       (protocol) =>
         this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
     );
@@ -207,7 +217,7 @@ export class ClusterReachability {
    * @param {number} latency
    * @returns {void}
    */
-  private storeLatencyResult(protocol: 'udp' | 'tcp', latency: number) {
+  private storeLatencyResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -227,6 +237,7 @@ export class ClusterReachability {
    */
   private registerIceCandidateListener() {
     this.pc.onicecandidate = (e) => {
+      const TURN_TLS_PORT = 443;
       const CANDIDATE_TYPES = {
         SERVER_REFLEXIVE: 'srflx',
         RELAY: 'relay',
@@ -239,7 +250,8 @@ export class ClusterReachability {
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
-          this.storeLatencyResult('tcp', this.getElapsedTime());
+          const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
+          this.storeLatencyResult(protocol, this.getElapsedTime());
           // we don't add public IP for TCP, because in the case of relay candidates
           // e.candidate.address is the TURN server address, not the client's public IP
         }
@@ -275,6 +287,9 @@ export class ClusterReachability {
     this.result.tcp = {
       result: this.numTcpUrls > 0 ? 'unreachable' : 'untested',
     };
+    this.result.xtls = {
+      result: this.numXTlsUrls > 0 ? 'unreachable' : 'untested',
+    };
 
     try {
       const offer = await this.pc.createOffer({offerToReceiveAudio: true});

package/src/reachability/index.ts

@@ -22,10 +22,14 @@ export type ReachabilityMetrics = {
   reachability_public_udp_failed: number;
   reachability_public_tcp_success: number;
   reachability_public_tcp_failed: number;
+  reachability_public_xtls_success: number;
+  reachability_public_xtls_failed: number;
   reachability_vmn_udp_success: number;
   reachability_vmn_udp_failed: number;
   reachability_vmn_tcp_success: number;
   reachability_vmn_tcp_failed: number;
+  reachability_vmn_xtls_success: number;
+  reachability_vmn_xtls_failed: number;
 };
 
 /**
@@ -141,10 +145,14 @@ export default class Reachability {
       reachability_public_udp_failed: 0,
       reachability_public_tcp_success: 0,
       reachability_public_tcp_failed: 0,
+      reachability_public_xtls_success: 0,
+      reachability_public_xtls_failed: 0,
       reachability_vmn_udp_success: 0,
       reachability_vmn_udp_failed: 0,
       reachability_vmn_tcp_success: 0,
       reachability_vmn_tcp_failed: 0,
+      reachability_vmn_xtls_success: 0,
+      reachability_vmn_xtls_failed: 0,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -156,6 +164,10 @@ export default class Reachability {
         const outcome = result.tcp.result === 'reachable' ? 'success' : 'failed';
         stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
       }
+      if (result.xtls && result.xtls.result !== 'untested') {
+        const outcome = result.xtls.result === 'reachable' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_xtls_${outcome}`] += 1;
+      }
     };
 
     try {
@@ -338,7 +350,10 @@ export default class Reachability {
     LoggerProxy.logger.log(
       `Reachability:index#performReachabilityChecks --> doing UDP${
         // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : ''
+        this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : ''
+      }${
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : ''
       } reachability checks`
     );
 
@@ -354,6 +369,14 @@ export default class Reachability {
         cluster.tcp = [];
       }
 
+      const includeTlsReachability =
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+
+      if (!includeTlsReachability) {
+        cluster.xtls = [];
+      }
+
       this.clusterReachability[key] = new ClusterReachability(key, cluster);
 
       return this.clusterReachability[key].start().then((result) => {

package/src/reachability/request.ts

@@ -34,17 +34,21 @@ class ReachabilityRequest {
    * @returns {Promise}
    */
   getClusters = (ipVersion?: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
-    this.webex
-      .request({
-        method: HTTP_VERBS.GET,
-        shouldRefreshAccessToken: false,
-        api: API.CALLIOPEDISCOVERY,
-        resource: RESOURCE.CLUSTERS,
-        qs: {
-          JCSupport: 1,
-          ipver: ipVersion,
-        },
-      })
+    this.webex.internal.newMetrics.callDiagnosticLatencies
+      .measureLatency(
+        () =>
+          this.webex.request({
+            method: HTTP_VERBS.GET,
+            shouldRefreshAccessToken: false,
+            api: API.CALLIOPEDISCOVERY,
+            resource: RESOURCE.CLUSTERS,
+            qs: {
+              JCSupport: 1,
+              ipver: ipVersion,
+            },
+          }),
+        'internal.get.cluster.time'
+      )
       .then((res) => {
         const {clusters, joinCookie} = res.body;
 

package/src/reachability/util.ts

@@ -22,3 +22,24 @@ export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
 
   return url.toString();
 }
+
+/**
+ * Converts a stun url to a turns url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @returns {string} url of a turns server
+ */
+export function convertStunUrlToTurnTls(stunUrl: string) {
+  // stunUrl looks like this: "stun:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443"
+  // and we need it to be like this: "turns:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443?transport=tcp"
+  const url = new URL(stunUrl);
+
+  if (url.protocol !== 'stun:') {
+    throw new Error(`Not a STUN URL: ${stunUrl}`);
+  }
+
+  url.protocol = 'turns:';
+  url.searchParams.append('transport', 'tcp');
+
+  return url.toString();
+}

package/src/reconnection-manager/index.ts

@@ -568,7 +568,7 @@ export default class ReconnectionManager {
 
     const iceServers = [];
 
-    if (turnServerResult.turnServerInfo) {
+    if (turnServerResult.turnServerInfo?.url) {
       iceServers.push({
         urls: turnServerResult.turnServerInfo.url,
         username: turnServerResult.turnServerInfo.username || '',