@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

package/src/hashTree/utils.ts

@@ -60,3 +60,39 @@ export const deleteNestedObjectsWithHtMeta = (
     }
   }
 };
+
+/**
+ * Reorders items so that those matching the given priority list come first (in priority order),
+ * followed by everything else in their original order.
+ *
+ * @param {Array<T>} items - The items to reorder
+ * @param {string[]} priority - Ordered list of names that should come first
+ * @returns {Array<T>} A new array with prioritized items first
+ */
+export function sortByInitPriority<T extends {name: string}>(items: T[], priority: string[]): T[] {
+  const prioritized = priority
+    .map((name) => items.find((item) => item.name === name))
+    .filter(Boolean) as T[];
+  const rest = items.filter((item) => !priority.includes(item.name));
+
+  return [...prioritized, ...rest];
+}
+
+/**
+ * Sleeps for the specified amount of milliseconds
+ *
+ * @param {number} ms amount of milliseconds to sleep
+ * @returns {Promise<void>} A promise that resolves after the specified delay
+ */
+export function sleep(ms: number): Promise<void> {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve) => {
+    // start a timer that will resolve the promise after the specified delay
+    setTimeout(() => {
+      resolve();
+    }, ms);
+  });
+}

package/src/index.ts

@@ -65,6 +65,12 @@ export * as REACTIONS from './reactions/reactions';
 export * as sdkAnnotationTypes from './annotation/annotation.types';
 export * as MeetingInfoV2 from './meeting-info/meeting-info-v2';
 export {type Reaction} from './reactions/reactions.type';
+export {SitePreferenceSelectOption} from './meetings/meetings.types';
+export type {
+  FetchSitePreferencesMeViaSiteOptions,
+  SitePreferencesResponse,
+} from './meetings/meetings.types';
+export type {Interpreter, InterpreterUsingResource} from './interpretation/interpretation.types';
 
 export {
   CaptchaError,

package/src/interceptors/dataChannelAuthToken.ts

@@ -3,13 +3,11 @@
  */
 
 import {Interceptor} from '@webex/http-core';
+import LLMChannel from '@webex/internal-plugin-llm';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY} from './constant';
 import {isJwtTokenExpired} from './utils';
-
-/*!
- * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
- */
+import {LLM_DEFAULT_SESSION, LLM_PRACTICE_SESSION, LOCUS_URL} from '../constants';
 
 const retryCountMap = new Map();
 interface HttpLikeError extends Error {
@@ -20,7 +18,7 @@ interface HttpLikeError extends Error {
  * @class
  */
 export default class DataChannelAuthTokenInterceptor extends Interceptor {
-  private _refreshDataChannelToken: () => Promise<string>;
+  private _refreshDataChannelToken: (requestUrl?: string) => Promise<string>;
   private _isDataChannelTokenEnabled: () => Promise<boolean>;
   constructor(options) {
     super(options);
@@ -42,13 +40,91 @@ export default class DataChannelAuthTokenInterceptor extends Interceptor {
         return this.internal.llm.isDataChannelTokenEnabled();
       },
 
-      refreshDataChannelToken: async () => {
-        // @ts-ignore
-        const {body} = await this.internal.llm.refreshDataChannelToken();
-        const {datachannelToken, dataChannelTokenType} = body ?? {};
+      // Route refresh by request URL in two steps:
+      // 1) Match active LLM sessions (supports non-default/multiple sessions)
+      // 2) If no session matches, resolve locusUrl and refresh via owning meeting
+      // If neither route matches, fall back to the default-session refresh.
+      refreshDataChannelToken: async (requestUrl?: string) => {
+        let sessionId;
+        let meeting;
 
+        if (typeof requestUrl === 'string') {
+          // @ts-ignore
+          sessionId = this.internal.llm.getSessionIdByDatachannelUrl?.(requestUrl);
+
+          if (!sessionId) {
+            // @ts-ignore
+            const locusUrl = this.internal.llm.getLocusUrlByDatachannelUrl?.(requestUrl);
+
+            if (locusUrl) {
+              // @ts-ignore
+              meeting = this.meetings?.getMeetingByType?.(LOCUS_URL, locusUrl);
+            }
+          }
+
+          if (!meeting) {
+            // Fallback: registerAndConnect() pre-populates datachannelUrl in
+            // connections before calling register(), so getSessionIdByDatachannelUrl
+            // above should normally resolve. This scan covers any residual gap
+            // where connections are not yet populated (e.g. if setRefreshHandler
+            // is called on a session that has no connection entry at all).
+            // @ts-ignore
+            const allMeetings = this.meetings?.getAllMeetings?.() || {};
+
+            meeting = Object.values(allMeetings).find((activeMeeting: any) => {
+              const info = activeMeeting?.locusInfo?.info || {};
+
+              return (
+                (info.practiceSessionDatachannelUrl &&
+                  LLMChannel.matchesDatachannelRequestUrl(
+                    requestUrl,
+                    info.practiceSessionDatachannelUrl
+                  )) ||
+                (info.datachannelUrl &&
+                  LLMChannel.matchesDatachannelRequestUrl(requestUrl, info.datachannelUrl))
+              );
+            });
+
+            if (!sessionId) {
+              // @ts-ignore
+              const info = meeting?.locusInfo?.info || {};
+
+              if (
+                info.practiceSessionDatachannelUrl &&
+                LLMChannel.matchesDatachannelRequestUrl(
+                  requestUrl,
+                  info.practiceSessionDatachannelUrl
+                )
+              ) {
+                sessionId = LLM_PRACTICE_SESSION;
+              } else if (
+                info.datachannelUrl &&
+                LLMChannel.matchesDatachannelRequestUrl(requestUrl, info.datachannelUrl)
+              ) {
+                sessionId = LLM_DEFAULT_SESSION;
+              }
+            }
+          }
+        }
+
+        let result;
+        if (meeting) {
+          result = await meeting.refreshDataChannelToken();
+        } else {
+          // @ts-ignore
+          result = await this.internal.llm.refreshDataChannelToken(sessionId);
+        }
+
+        if (!result?.body) {
+          throw new Error('DataChannel token refresh returned no payload');
+        }
+        const {datachannelToken, dataChannelTokenType} = result.body;
+        const tokenStoreKey = dataChannelTokenType || sessionId;
+        const ownerMeetingId =
+          // @ts-ignore
+          meeting?.id || this.internal.llm.getOwnerMeetingId?.(tokenStoreKey);
         // @ts-ignore
-        this.internal.llm.setDatachannelToken(datachannelToken, dataChannelTokenType);
+        this.internal.llm.setDatachannelToken(datachannelToken, tokenStoreKey, ownerMeetingId);
 
         return datachannelToken;
       },
@@ -87,7 +163,7 @@ export default class DataChannelAuthTokenInterceptor extends Interceptor {
 
     if (isJwtTokenExpired(token)) {
       try {
-        const newToken = await this._refreshDataChannelToken();
+        const newToken = await this._refreshDataChannelToken(options.uri || options.url);
         options.headers[DATA_CHANNEL_AUTH_HEADER] = newToken;
       } catch (e) {
         LoggerProxy.logger.warn(`DataChannelAuthTokenInterceptor: refresh failed: ${e.message}`);
@@ -144,7 +220,7 @@ export default class DataChannelAuthTokenInterceptor extends Interceptor {
       setTimeout(async () => {
         const key = this.getRetryKey(options);
         try {
-          const newToken = await this._refreshDataChannelToken();
+          const newToken = await this._refreshDataChannelToken(options.uri || options.url);
 
           options.headers[DATA_CHANNEL_AUTH_HEADER] = newToken;
 

package/src/interceptors/locusRetry.ts

@@ -18,12 +18,33 @@ export default class LocusRetryStatusInterceptor extends Interceptor {
   }
 
   /**
-   * Handle response errors
-   * @param {Object} options
-   * @param {WebexHttpError} reason
-   * @returns {Promise<WebexHttpError>}
+   * Check whether a URI is a Locus /hashtree or /sync endpoint.
+   * @param {string} uri
+   * @returns {boolean}
    */
+  private static isLocusHashtreeOrSync(uri: string): boolean {
+    try {
+      const {pathname} = new URL(uri);
+
+      return (
+        pathname.includes('/locus/') &&
+        (pathname.endsWith('/hashtree') || pathname.endsWith('/sync'))
+      );
+    } catch {
+      return false;
+    }
+  }
+
   onResponseError(options, reason) {
+    // Don't retry /hashtree or /sync calls for 429 or any 5xx — during a sync storm retries
+    // make things worse. The normal sync timers will handle recovery for these endpoints.
+    if (
+      (reason.statusCode === 429 || reason.statusCode >= 500) &&
+      LocusRetryStatusInterceptor.isLocusHashtreeOrSync(options.uri)
+    ) {
+      return Promise.reject(reason);
+    }
+
     if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {
       const hasRetriedLocusRequest = rateLimitExpiryTime.get(this);
       const retryAfterTime = options.headers['retry-after'] || 2000;

package/src/interpretation/index.ts

@@ -4,8 +4,10 @@
 import {WebexPlugin} from '@webex/webex-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {HTTP_VERBS, INTERPRETATION, LOCUSEVENT, MEETINGS} from '../constants';
+import MeetingUtil from '../meeting/util';
 
 import SILanguageCollection from './collection';
+import {Interpreter} from './interpretation.types';
 
 /**
  * @class SimultaneousInterpretation
@@ -182,7 +184,9 @@ const SimultaneousInterpretation = WebexPlugin.extend({
    * @param {Array} interpreters
    * @returns {Promise}
    */
-  updateInterpreters(interpreters) {
+  updateInterpreters(interpreters: Interpreter[]) {
+    const meeting = this.webex.meetings.meetingCollection.getByKey('locusUrl', this.locusUrl);
+
     return this.request({
       method: HTTP_VERBS.PATCH,
       uri: `${this.locusUrl}/controls`,
@@ -191,10 +195,16 @@ const SimultaneousInterpretation = WebexPlugin.extend({
           interpreters,
         },
       },
-    }).catch((error) => {
-      LoggerProxy.logger.error('Meeting:interpretation#updateInterpreters failed', error);
-      throw error;
-    });
+    })
+      .then((response) => {
+        MeetingUtil.updateLocusFromApiResponse(meeting, response);
+
+        return response;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:interpretation#updateInterpreters failed', error);
+        throw error;
+      });
   },
   /**
    * Change direction of interpretation for an interpreter participant
@@ -209,6 +219,8 @@ const SimultaneousInterpretation = WebexPlugin.extend({
       return Promise.reject(new Error('Missing self participant id'));
     }
 
+    const meeting = this.webex.meetings.meetingCollection.getByKey('locusUrl', this.locusUrl);
+
     return this.request({
       method: HTTP_VERBS.PATCH,
       uri: `${this.locusUrl}/participant/${this.selfParticipantId}/controls`,
@@ -220,10 +232,16 @@ const SimultaneousInterpretation = WebexPlugin.extend({
           order: this.order,
         },
       },
-    }).catch((error) => {
-      LoggerProxy.logger.error('Meeting:interpretation#changeDirection failed', error);
-      throw error;
-    });
+    })
+      .then((response) => {
+        MeetingUtil.updateLocusFromApiResponse(meeting, response);
+
+        return response;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:interpretation#changeDirection failed', error);
+        throw error;
+      });
   },
   /**
    * Sets up a listener for handoff requests from mercury

package/src/interpretation/interpretation.types.ts

@@ -0,0 +1,11 @@
+export type InterpreterUsingResource = {
+  id: string;
+  email?: string;
+};
+
+export type Interpreter = {
+  order: number;
+  sourceLanguage: string;
+  targetLanguage: string;
+  usingResource: InterpreterUsingResource;
+};

package/src/locus-info/controlsUtils.ts

@@ -26,7 +26,9 @@ ControlsUtils.parse = (controls: any) => {
       modifiedBy: ControlsUtils.getId(controls),
       paused: controls.record.paused ? controls.record.paused : false,
       recording: controls.record.recording,
-      lastModified: controls.record.meta.lastModified,
+      lastModified: controls.record.meta?.lastModified,
+      modifiedByServiceAppName: controls.record.meta?.modifiedByServiceAppName,
+      modifiedByServiceAppId: controls.record.meta?.modifiedByServiceAppId,
     };
   }