@webex/plugin-meetings 3.11.0-next.4 → 3.11.0-next.41

package/src/hashTree/types.ts

@@ -10,6 +10,8 @@ export const ObjectType = {
   fullState: 'fullstate',
   links: 'links',
   control: 'controlentry',
+  metadata: 'metadata',
+  embeddedApp: 'embeddedapp',
 } as const;
 
 export type ObjectType = Enum<typeof ObjectType>;
@@ -23,7 +25,9 @@ export const ObjectTypeToLocusKeyMap = {
   [ObjectType.participant]: 'participants', // note: each object is a single participant in participants array
   [ObjectType.mediaShare]: 'mediaShares', // note: each object is a single mediaShare in mediaShares array
   [ObjectType.control]: 'controls', // note: each object is a single control entry in controls object
+  [ObjectType.embeddedApp]: 'embeddedApps', // note: each object is a single embedded app in embeddedApps array
 };
+
 export interface HtMeta {
   elementId: {
     type: ObjectType;

package/src/hashTree/utils.ts

@@ -11,6 +11,15 @@ export function isSelf(object: HashTreeObject) {
   return object.htMeta.elementId.type.toLowerCase() === ObjectType.self;
 }
 
+/**
+ * Checks if the given hash tree object is of type "Metadata"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "Metadata", false otherwise
+ */
+export function isMetadata(object: HashTreeObject) {
+  return object.htMeta.elementId.type.toLowerCase() === ObjectType.metadata;
+}
+
 /**
  * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
  *

package/src/index.ts

@@ -3,7 +3,11 @@ import {registerPlugin} from '@webex/webex-core';
 
 import Meetings from './meetings';
 import config from './config';
-import {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor} from './interceptors';
+import {
+  LocusRetryStatusInterceptor,
+  LocusRouteTokenInterceptor,
+  DataChannelAuthTokenInterceptor,
+} from './interceptors';
 import CaptchaError from './common/errors/captcha-error';
 import IntentToJoinError from './common/errors/intent-to-join';
 import PasswordError from './common/errors/password-error';
@@ -25,6 +29,7 @@ registerPlugin('meetings', Meetings, {
   interceptors: {
     LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,
     LocusRouteTokenInterceptor: LocusRouteTokenInterceptor.create,
+    DataChannelAuthTokenInterceptor: DataChannelAuthTokenInterceptor.create,
   },
 });
 
@@ -80,3 +85,5 @@ export {
 export {RemoteMedia} from './multistream/remoteMedia';
 
 export {default as TriggerProxy} from './common/events/trigger-proxy';
+
+export {getAIEnablementApprover} from './aiEnableRequest/utils';

package/src/interceptors/constant.ts

@@ -0,0 +1,6 @@
+const DATA_CHANNEL_AUTH_HEADER = 'Data-Channel-Auth-Token';
+const MAX_RETRY = 1;
+const RETRY_INTERVAL = 2000;
+const RETRY_KEY = '_dcRetryKey';
+
+export {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY};

package/src/interceptors/dataChannelAuthToken.ts

@@ -0,0 +1,142 @@
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY} from './constant';
+
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+
+const retryCountMap = new Map();
+interface HttpLikeError extends Error {
+  statusCode?: number;
+  original?: any;
+}
+/**
+ * @class
+ */
+export default class DataChannelAuthTokenInterceptor extends Interceptor {
+  private _refreshDataChannelToken: () => Promise<string>;
+  private _isDataChannelTokenEnabled: () => Promise<boolean>;
+  constructor(options) {
+    super(options);
+
+    this._refreshDataChannelToken = options.refreshDataChannelToken;
+    this._isDataChannelTokenEnabled = options.isDataChannelTokenEnabled;
+  }
+
+  /**
+   * @returns {DataChannelAuthTokenInterceptor}
+   */
+  static create() {
+    // @ts-ignore
+    return new DataChannelAuthTokenInterceptor({
+      webex: this,
+
+      isDataChannelTokenEnabled: async () => {
+        // @ts-ignore
+        return this.internal.llm.isDataChannelTokenEnabled();
+      },
+
+      refreshDataChannelToken: async () => {
+        // @ts-ignore
+        const {body} = await this.internal.llm.refreshDataChannelToken();
+        const {datachannelToken, dataChannelTokenType} = body ?? {};
+
+        // @ts-ignore
+        this.internal.llm.setDatachannelToken(datachannelToken, dataChannelTokenType);
+
+        return datachannelToken;
+      },
+    });
+  }
+
+  private getRetryKey(options) {
+    if (!options[RETRY_KEY]) {
+      options[RETRY_KEY] = `${Date.now()}-${Math.random()}`;
+    }
+
+    return options[RETRY_KEY];
+  }
+
+  // Helper function to get header value case insensitively
+  private getHeader(headers: Record<string, string>, name: string) {
+    const key = Object.keys(headers).find((k) => k.toLowerCase() === name.toLowerCase());
+
+    return key ? headers[key] : undefined;
+  }
+
+  /**
+   * Intercept responses and, on 401/403 with `Data-Channel-Auth-Token` header,
+   * attempt to refresh the data channel token and retry the original request once.
+   *
+   * @param {Object} options
+   * @param {Object} reason
+   * @returns {Promise<HttpResponse>}
+   */
+  async onResponseError(options, reason) {
+    const token = this.getHeader(options.headers, DATA_CHANNEL_AUTH_HEADER);
+    const enabled = await this._isDataChannelTokenEnabled();
+
+    if (!token || !enabled) {
+      return Promise.reject(reason);
+    }
+
+    if (reason.statusCode !== 401 && reason.statusCode !== 403) {
+      return Promise.reject(reason);
+    }
+
+    const key = this.getRetryKey(options);
+    const retryCount = retryCountMap.get(key) || 0;
+
+    if (retryCount >= MAX_RETRY) {
+      LoggerProxy.logger.error(`data channel token refresh exceeded max retry (${MAX_RETRY})`);
+      retryCountMap.delete(key);
+
+      return Promise.reject(reason);
+    }
+
+    retryCountMap.set(key, retryCount + 1);
+
+    return this.refreshTokenAndRetryWithDelay(options);
+  }
+
+  /**
+   * Retry the failed data channel request after a delay.
+   * Refreshes the Data-Channel-Auth-Token and re-sends the original request.
+   *
+   * @param {Object} options - Original request options.
+   * @returns {Promise<HttpResponse>} - Resolves on successful retry.
+   */
+  refreshTokenAndRetryWithDelay(options) {
+    return new Promise((resolve, reject) => {
+      setTimeout(async () => {
+        const key = this.getRetryKey(options);
+        try {
+          const newToken = await this._refreshDataChannelToken();
+
+          options.headers[DATA_CHANNEL_AUTH_HEADER] = newToken;
+
+          // @ts-ignore
+          const res = await this.webex.request(options);
+          retryCountMap.delete(key);
+
+          resolve(res);
+        } catch (e) {
+          retryCountMap.delete(key);
+
+          const msg = e?.message || String(e);
+
+          const err: HttpLikeError = new Error(`DataChannel token refresh failed: ${msg}`);
+          err.statusCode = e?.statusCode;
+          err.original = e;
+
+          reject(err);
+        }
+      }, RETRY_INTERVAL);
+    });
+  }
+}

package/src/interceptors/index.ts

@@ -1,4 +1,5 @@
 import LocusRetryStatusInterceptor from './locusRetry';
 import LocusRouteTokenInterceptor from './locusRouteToken';
+import DataChannelAuthTokenInterceptor from './dataChannelAuthToken';
 
-export {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor};
+export {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor, DataChannelAuthTokenInterceptor};

package/src/interpretation/index.ts

@@ -3,7 +3,7 @@
  */
 import {WebexPlugin} from '@webex/webex-core';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {HTTP_VERBS, INTERPRETATION, MEETINGS} from '../constants';
+import {HTTP_VERBS, INTERPRETATION, LOCUSEVENT, MEETINGS} from '../constants';
 
 import SILanguageCollection from './collection';
 
@@ -230,7 +230,7 @@ const SimultaneousInterpretation = WebexPlugin.extend({
    * @returns {void}
    */
   listenToHandoffRequests() {
-    this.listenTo(this.webex.internal.mercury, 'event:locus.approval_request', (event) => {
+    this.listenTo(this.webex.internal.mercury, `event:${LOCUSEVENT.APPROVAL_REQUEST}`, (event) => {
       if (event?.data?.approval?.resourceType === INTERPRETATION.RESOURCE_TYPE) {
         const {receivers, initiator, actionType, url} = event.data.approval;
         const receiverId = receivers?.[0]?.participantId;

package/src/locus-info/controlsUtils.ts

@@ -42,6 +42,7 @@ ControlsUtils.parse = (controls: any) => {
       caption: controls.transcribe.caption,
       spokenLanguage: controls.transcribe.spokenLanguage,
       hesiodLlmId: controls.transcribe.hesiodLlmId,
+      aiSummaryNotification: controls.transcribe.aiSummaryNotification,
     };
   }
 
@@ -208,6 +209,16 @@ ControlsUtils.getControls = (oldControls: any, newControls: any) => {
         !isEqual(previous?.transcribe?.hesiodLlmId, current?.transcribe?.hesiodLlmId) &&
         !!(previous?.transcribe?.hesiodLlmId || current?.transcribe?.hesiodLlmId),
 
+      hasAiSummaryNotificationChanged:
+        current?.transcribe &&
+        !isEqual(
+          previous?.transcribe?.aiSummaryNotification,
+          current?.transcribe?.aiSummaryNotification
+        ) &&
+        !!(
+          previous?.transcribe?.aiSummaryNotification || current?.transcribe?.aiSummaryNotification
+        ),
+
       hasTranscribeSpokenLanguageChanged:
         current?.transcribe &&
         !isEqual(previous?.transcribe?.spokenLanguage, current?.transcribe?.spokenLanguage) &&