@webex/plugin-meetings 3.12.0-next.65 → 3.12.0-next.66

package/src/meeting/index.ts

@@ -136,6 +136,7 @@ import {
   STAGE_MANAGER_TYPE,
   LOCUSEVENT,
   LOCUS_LLM_EVENT,
+  LLM_DEFAULT_SESSION,
   LLM_PRACTICE_SESSION,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
@@ -3507,8 +3508,6 @@ export default class Meeting extends StatelessWebexPlugin {
         this.recordingController.setLocusUrl(this.locusUrl);
         this.controlsOptionsManager.setLocusUrl(this.locusUrl, !!isMainLocus);
         this.webinar.locusUrlUpdate(url);
-        // @ts-ignore
-        this.webex.internal.llm.setRefreshHandler(() => this.refreshDataChannelToken());
 
         Trigger.trigger(
           this,
@@ -3777,7 +3776,7 @@ export default class Meeting extends StatelessWebexPlugin {
       });
       this.updateLLMConnection();
     });
-    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, (payload) => {
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, async (payload) => {
       this.stopKeepAlive();
 
       if (payload) {
@@ -3804,13 +3803,15 @@ export default class Meeting extends StatelessWebexPlugin {
       }
       this.rtcMetrics?.sendNextMetrics();
 
-      this.ensureDefaultDatachannelTokenAfterAdmit().catch((error) => {
+      try {
+        await this.ensureDefaultDatachannelTokenAfterAdmit();
+      } catch (error) {
         LoggerProxy.logger.warn(
           `Meeting:index#setUpLocusInfoSelfListener --> failed post-admit token prefetch flow: ${
             error?.message || String(error)
           }`
         );
-      });
+      }
 
       this.updateLLMConnection();
     });
@@ -6499,16 +6500,23 @@ export default class Meeting extends StatelessWebexPlugin {
     throwOnError?: boolean;
   } = {}): Promise<void> => {
     // @ts-ignore - Fix type
-    const currentOwner = this.webex.internal.llm.getOwnerMeetingId();
-    const isOwner = !currentOwner || currentOwner === this.id;
+    // @ts-ignore - Fix type
+    const {currentOwner, isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.id,
+      LLM_DEFAULT_SESSION
+    );
 
     try {
       if (isOwner) {
         // @ts-ignore - Fix type
-        await this.webex.internal.llm.disconnectLLM({
-          code: 3050,
-          reason: 'done (permanent)',
-        });
+        await this.webex.internal.llm.disconnectLLM(
+          {
+            code: 3050,
+            reason: 'done (permanent)',
+          },
+          LLM_DEFAULT_SESSION,
+          this.id
+        );
       } else {
         LoggerProxy.logger.info(
           `Meeting:index#cleanupLLMConneciton --> skipping disconnect; LLM owned by meeting ${currentOwner}, not ${this.id}`
@@ -6530,27 +6538,31 @@ export default class Meeting extends StatelessWebexPlugin {
       }
       this.stopListeningForLLMEvents();
 
-      // If this meeting owned (or could have owned) the default LLM session,
-      // always release the owner tag here regardless of whether disconnectLLM
-      // resolved. `disconnectLLM` only clears the owner on its success path,
-      // so a failed disconnect would otherwise leave a stale owner pointing
-      // at a torn-down meeting and permanently block other meetings'
-      // `updateLLMConnection` calls via the ownership guard.
+      // Re-check ownership after awaiting disconnectLLM. If ownership changed
+      // while cleanup was in flight, do not clear another meeting's owner tag.
       if (isOwner) {
-        // @ts-ignore - Fix type
-        this.webex.internal.llm.setOwnerMeetingId?.(undefined);
+        const {currentOwner: currentOwnerAfterCleanup} =
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.resolveSessionOwnership(this.id, LLM_DEFAULT_SESSION);
+
+        if (currentOwnerAfterCleanup === this.id) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(undefined);
+        }
       }
     }
   };
 
   /**
-   * Clears all data channel tokens stored in LLM.
-   * Called during meeting cleanup to ensure stale tokens are not reused.
+   * Clears data channel tokens associated with this meeting ownership.
+   * Ownership checks are enforced in internal-plugin-llm.
    * @returns {void}
    */
   clearDataChannelToken(): void {
     // @ts-ignore
-    this.webex.internal.llm.resetDatachannelTokens();
+    this.webex.internal.llm.clearDatachannelToken(LLM_DEFAULT_SESSION, this.id);
+    // @ts-ignore
+    this.webex.internal.llm.clearDatachannelToken(LLM_PRACTICE_SESSION, this.id);
   }
 
   /**
@@ -6565,14 +6577,15 @@ export default class Meeting extends StatelessWebexPlugin {
 
     if (datachannelToken) {
       // @ts-ignore
-      this.webex.internal.llm.setDatachannelToken(datachannelToken, DataChannelTokenType.Default);
+      this.webex.internal.llm.setDatachannelToken(datachannelToken, LLM_DEFAULT_SESSION, this.id);
     }
 
     if (practiceSessionDatachannelToken) {
       // @ts-ignore
       this.webex.internal.llm.setDatachannelToken(
         practiceSessionDatachannelToken,
-        DataChannelTokenType.PracticeSession
+        LLM_PRACTICE_SESSION,
+        this.id
       );
     }
   }
@@ -6585,7 +6598,10 @@ export default class Meeting extends StatelessWebexPlugin {
   private async ensureDefaultDatachannelTokenAfterAdmit(): Promise<boolean> {
     try {
       // @ts-ignore
-      const datachannelToken = this.webex.internal.llm.getDatachannelToken();
+      const datachannelToken = this.webex.internal.llm.getDatachannelToken(
+        LLM_DEFAULT_SESSION,
+        this.id
+      );
       // @ts-ignore
       const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
 
@@ -6607,7 +6623,8 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       this.webex.internal.llm.setDatachannelToken(
         fetchedDatachannelToken,
-        DataChannelTokenType.Default
+        LLM_DEFAULT_SESSION,
+        this.id
       );
 
       return true;
@@ -6634,11 +6651,6 @@ export default class Meeting extends StatelessWebexPlugin {
 
     const isJoined = this.isJoined();
 
-    // @ts-ignore
-    const datachannelToken = this.webex.internal.llm.getDatachannelToken(
-      DataChannelTokenType.Default
-    );
-
     const dataChannelUrl = datachannelUrl;
 
     // Ownership guard: when the default LLM session is already connected and
@@ -6648,10 +6660,33 @@ export default class Meeting extends StatelessWebexPlugin {
     // connection when this meeting is the current owner, or when no owner is
     // set yet (first claim).
     // @ts-ignore - Fix type
-    const currentOwner = this.webex.internal.llm.getOwnerMeetingId();
+    const {currentOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.id,
+      LLM_DEFAULT_SESSION
+    );
 
+    // Capture connectivity before any reconnect attempt. If LLM was already
+    // connected, we must respect current ownership. If it was disconnected,
+    // this flow may reclaim stale owner tags after a fresh connect.
     // @ts-ignore - Fix type
-    if (this.webex.internal.llm.isConnected()) {
+    const wasConnected = this.webex.internal.llm.isConnected();
+
+    // Prefer ownership-scoped token read. For disconnected stale-owner reclaim
+    // flows, fallback to ownerless read so initial register can still carry a
+    // token and recover from stale ownership without 401/403 dead-end.
+    // @ts-ignore - Fix type
+    let datachannelToken = this.webex.internal.llm.getDatachannelToken(
+      LLM_DEFAULT_SESSION,
+      this.id
+    );
+
+    if (!datachannelToken && !wasConnected && currentOwner && currentOwner !== this.id) {
+      // @ts-ignore - Fix type
+      datachannelToken = this.webex.internal.llm.getDatachannelToken(LLM_DEFAULT_SESSION);
+    }
+
+    // @ts-ignore - Fix type
+    if (wasConnected) {
       if (currentOwner && currentOwner !== this.id) {
         // Another meeting owns the live LLM socket. We must not disconnect
         // or reconfigure it -- doing so would tear down a session the
@@ -6684,6 +6719,20 @@ export default class Meeting extends StatelessWebexPlugin {
       return undefined;
     }
 
+    // Bind refresh handler before registration so interceptor-triggered token
+    // refresh during register POST can resolve a valid handler.
+    // Prefer this meeting as owner, but allow owner-less fallback when a stale
+    // foreign owner tag is present on a disconnected session.
+    const refreshHandlerOwnerMeetingId =
+      currentOwner && currentOwner !== this.id ? undefined : this.id;
+    const shouldAlignRefreshHandlerAfterOwnershipClaim = refreshHandlerOwnerMeetingId !== this.id;
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.setRefreshHandler(
+      () => this.refreshDataChannelToken(),
+      LLM_DEFAULT_SESSION,
+      refreshHandlerOwnerMeetingId
+    );
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
       .registerAndConnect(url, dataChannelUrl, datachannelToken)
@@ -6693,7 +6742,33 @@ export default class Meeting extends StatelessWebexPlugin {
         // subsequent cross-meeting `updateLLMConnection` / `cleanupLLMConneciton`
         // calls can detect and skip work that doesn't belong to them.
         // @ts-ignore - Fix type
-        this.webex.internal.llm.setOwnerMeetingId?.(this.id);
+        const {isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+          this.id,
+          LLM_DEFAULT_SESSION
+        );
+        const canReclaimAfterDisconnectedStart = !wasConnected;
+
+        // Refresh handler is pre-bound before registerAndConnect so token
+        // refresh can work even during the registration request itself.
+        if (isOwner || canReclaimAfterDisconnectedStart) {
+          // Record ownership of the default LLM session for this meeting so
+          // subsequent cross-meeting `updateLLMConnection` / `cleanupLLMConneciton`
+          // calls can detect and skip work that doesn't belong to them.
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(this.id);
+
+          // If we pre-bound refresh ownerlessly (stale-owner reclaim path),
+          // align the handler with the newly claimed owner immediately after
+          // ownership is updated.
+          if (shouldAlignRefreshHandlerAfterOwnershipClaim) {
+            // @ts-ignore - Fix type
+            this.webex.internal.llm.setRefreshHandler(
+              () => this.refreshDataChannelToken(),
+              LLM_DEFAULT_SESSION,
+              this.id
+            );
+          }
+        }
         // @ts-ignore - Fix type
         this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
         // @ts-ignore - Fix type
@@ -9991,21 +10066,8 @@ export default class Meeting extends StatelessWebexPlugin {
     // again would double-emit MEETING_STOPPED_RECEIVING_TRANSCRIPTION
     // because stopTranscription() always fires its trigger.
     //
-    // Ownership-aware token clear: only clear the shared LLM data channel
-    // tokens when this meeting owns (or no meeting owns) the default LLM
-    // session. Otherwise we would wipe tokens still in use by another
-    // meeting's active LLM connection.
-    // @ts-ignore - Fix type
-    const currentOwner = this.webex.internal.llm.getOwnerMeetingId();
-    const isOwner = !currentOwner || currentOwner === this.id;
-
-    if (isOwner) {
-      this.clearDataChannelToken();
-    } else {
-      LoggerProxy.logger.info(
-        `Meeting:index#clearMeetingData --> skipping clearDataChannelToken; LLM owned by meeting ${currentOwner}, not ${this.id}`
-      );
-    }
+    // Ownership-aware token clear is encapsulated inside clearDataChannelToken().
+    this.clearDataChannelToken();
 
     await this.cleanupLLMConneciton({throwOnError: false});
   };

package/src/webinar/index.ts

@@ -4,7 +4,6 @@
 import {WebexPlugin, config} from '@webex/webex-core';
 import uuid from 'uuid';
 import {get} from 'lodash';
-import {DataChannelTokenType} from '@webex/internal-plugin-llm';
 import {
   _ID_,
   HEADERS,
@@ -185,6 +184,10 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise<void>}
    */
   async cleanupPSDataChannel() {
+    const {isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.meetingId,
+      LLM_PRACTICE_SESSION
+    );
     this.llmListeners = this.llmListeners || {};
 
     if (this._pendingOnlineListener) {
@@ -193,20 +196,47 @@ const Webinar = WebexPlugin.extend({
       this._pendingOnlineListener = null;
     }
 
-    // @ts-ignore - Fix type
-    await this.webex.internal.llm.disconnectLLM(
-      {
-        code: 3050,
-        reason: 'done (permanent)',
-      },
-      LLM_PRACTICE_SESSION
-    );
+    try {
+      // @ts-ignore - Fix type
+      const disconnected = await this.webex.internal.llm.disconnectLLM(
+        {
+          code: 3050,
+          reason: 'done (permanent)',
+        },
+        LLM_PRACTICE_SESSION,
+        this.meetingId
+      );
 
-    for (const {event, listenerKey} of PS_LLM_EVENTS) {
-      if (this.llmListeners[listenerKey]) {
+      if (!disconnected) {
+        LoggerProxy.logger.info(
+          `Webinar:index#cleanupPSDataChannel --> skipping disconnect; practice-session LLM is not owned by meeting ${this.meetingId}`
+        );
+      }
+    } catch (error) {
+      // disconnectLLM clears ownership only on success; release a stale owner
+      // tag here so other meeting instances can reclaim practice-session LLM.
+      if (isOwner) {
         // @ts-ignore - Fix type
-        this.webex.internal.llm.off(event, this.llmListeners[listenerKey]);
-        this.llmListeners[listenerKey] = null;
+        this.webex.internal.llm.setOwnerMeetingId?.(undefined, LLM_PRACTICE_SESSION);
+      }
+
+      throw error;
+    } finally {
+      if (this._practiceSessionRelayListener) {
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off(
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          this._practiceSessionRelayListener
+        );
+      }
+      this._practiceSessionRelayListener = null;
+
+      for (const {event, listenerKey} of PS_LLM_EVENTS) {
+        if (this.llmListeners[listenerKey]) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.off(event, this.llmListeners[listenerKey]);
+          this.llmListeners[listenerKey] = null;
+        }
       }
     }
   },
@@ -228,7 +258,8 @@ const Webinar = WebexPlugin.extend({
 
     // @ts-ignore
     const cachedToken = this.webex.internal.llm.getDatachannelToken(
-      DataChannelTokenType.PracticeSession
+      LLM_PRACTICE_SESSION,
+      this.meetingId
     );
 
     if (cachedToken) {
@@ -246,7 +277,8 @@ const Webinar = WebexPlugin.extend({
       // @ts-ignore
       this.webex.internal.llm.setDatachannelToken(
         datachannelToken,
-        dataChannelTokenType || DataChannelTokenType.PracticeSession
+        dataChannelTokenType || LLM_PRACTICE_SESSION,
+        this.meetingId
       );
 
       return datachannelToken;
@@ -274,6 +306,10 @@ const Webinar = WebexPlugin.extend({
 
     const meeting = this.getValidatedWebinarMeeting();
     const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+    const {currentOwner, isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.meetingId,
+      LLM_PRACTICE_SESSION
+    );
 
     if (!isPracticeSession) {
       await this.cleanupPSDataChannel();
@@ -281,13 +317,22 @@ const Webinar = WebexPlugin.extend({
       return undefined;
     }
 
+    if (!isOwner) {
+      LoggerProxy.logger.info(
+        `Webinar:index#updatePSDataChannel --> skipping; practice-session LLM owned by meeting ${currentOwner}, not ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
     // @ts-ignore - Fix type
     const {url = undefined, info: {practiceSessionDatachannelUrl = undefined} = {}} =
       meeting?.locusInfo || {};
 
     // @ts-ignore
     let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
-      DataChannelTokenType.PracticeSession
+      LLM_PRACTICE_SESSION,
+      this.meetingId
     );
 
     const isCaptionBoxOn = this.webex.internal.voicea.getIsCaptionBoxOn();
@@ -364,6 +409,30 @@ const Webinar = WebexPlugin.extend({
       practiceSessionDatachannelToken = refreshedPracticeSessionToken;
     }
 
+    const {currentOwner: currentOwnerBeforeConnect, isOwner: isOwnerBeforeConnect} =
+      this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+    if (!isOwnerBeforeConnect) {
+      LoggerProxy.logger.info(
+        `Webinar:index#updatePSDataChannel --> skipping pre-connect owner write; practice-session LLM owned by meeting ${currentOwnerBeforeConnect}, not ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
+    // Ensure refresh for practice datachannel requests is routed to this
+    // meeting only when we are actually about to connect the practice session.
+    // This avoids claiming ownership in flows that return early (e.g. missing
+    // practiceSessionDatachannelUrl or waiting for default session online).
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.setRefreshHandler(
+      () => meeting.refreshDataChannelToken(),
+      LLM_PRACTICE_SESSION,
+      this.meetingId
+    );
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.setOwnerMeetingId?.(this.meetingId, LLM_PRACTICE_SESSION);
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
       .registerAndConnect(
@@ -373,6 +442,18 @@ const Webinar = WebexPlugin.extend({
         LLM_PRACTICE_SESSION
       )
       .then((registerAndConnectResult) => {
+        const {currentOwner: currentOwnerAfterConnect, isOwner: isOwnerAfterConnect} =
+          this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+        if (this.meetingId && isOwnerAfterConnect) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(this.meetingId, LLM_PRACTICE_SESSION);
+        } else {
+          LoggerProxy.logger.info(
+            `Webinar:index#updatePSDataChannel --> skipping post-connect owner write; practice-session LLM owned by meeting ${currentOwnerAfterConnect}, not ${this.meetingId}`
+          );
+        }
+
         // Track the exact listener references so cleanupPSDataChannel can
         // unsubscribe deterministically, even if the meeting can no longer
         // be resolved at cleanup time.
@@ -395,6 +476,23 @@ const Webinar = WebexPlugin.extend({
         );
 
         return Promise.resolve(registerAndConnectResult);
+      })
+      .catch((error) => {
+        const {
+          currentOwner: currentOwnerAfterRegisterFailure,
+          isOwner: isOwnerAfterRegisterFailure,
+        } = this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+        if (isOwnerAfterRegisterFailure) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(undefined, LLM_PRACTICE_SESSION);
+        } else {
+          LoggerProxy.logger.info(
+            `Webinar:index#updatePSDataChannel --> skipping failure owner release; practice-session LLM owned by meeting ${currentOwnerAfterRegisterFailure}, not ${this.meetingId}`
+          );
+        }
+
+        throw error;
       });
   },