@webex/internal-plugin-llm 3.12.0-next.9 → 3.12.0-task-refactor.1

package/package.json

@@ -13,7 +13,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@webex/internal-plugin-mercury": "3.12.0-next.8"
+    "@webex/internal-plugin-mercury": "3.12.0-task-refactor.1"
   },
   "browserify": {
     "transform": [
@@ -27,10 +27,10 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/test-helper-chai": "3.11.0-next.1",
-    "@webex/test-helper-mocha": "3.11.0-next.1",
-    "@webex/test-helper-mock-webex": "3.11.0-next.1",
-    "@webex/test-helper-test-users": "3.11.0-next.1",
+    "@webex/test-helper-chai": "3.12.0-task-refactor.1",
+    "@webex/test-helper-mocha": "3.12.0-task-refactor.1",
+    "@webex/test-helper-mock-webex": "3.12.0-task-refactor.1",
+    "@webex/test-helper-test-users": "3.12.0-task-refactor.1",
     "eslint": "^8.24.0",
     "prettier": "^2.7.1",
     "sinon": "^9.2.4"
@@ -44,5 +44,5 @@
     "test:style": "eslint ./src/**/*.*",
     "test:unit": "webex-legacy-tools test --unit --runner jest"
   },
-  "version": "3.12.0-next.9"
+  "version": "3.12.0-task-refactor.1"
 }

package/src/constants.ts

@@ -1,14 +1,2 @@
 // eslint-disable-next-line import/prefer-default-export
 export const LLM = 'llm';
-
-export const LLM_DEFAULT_SESSION = 'llm-default-session';
-
-export const DATA_CHANNEL_WITH_JWT_TOKEN = 'data-channel-with-jwt-token';
-
-export const SUBSCRIPTION_AWARE_SUBCHANNELS_PARAM = 'subscriptionAwareSubchannels';
-
-export const DATA_CHNANEL_TYPE = {
-  TRANSCRIPTION: 'transcription',
-};
-
-export const AWARE_DATA_CHANNEL = [DATA_CHNANEL_TYPE.TRANSCRIPTION];

package/src/index.ts

@@ -1,10 +1,8 @@
 import * as WebexCore from '@webex/webex-core';
 import LLMChannel, {config} from './llm';
-import {DataChannelTokenType} from './llm.types';
 
 WebexCore.registerInternalPlugin('llm', LLMChannel, {
   config,
 });
 
-export {DataChannelTokenType};
 export {default} from './llm';

package/src/llm.ts

@@ -2,15 +2,9 @@
 
 import Mercury from '@webex/internal-plugin-mercury';
 
+import {LLM} from './constants';
 // eslint-disable-next-line no-unused-vars
-import {
-  LLM,
-  DATA_CHANNEL_WITH_JWT_TOKEN,
-  AWARE_DATA_CHANNEL,
-  SUBSCRIPTION_AWARE_SUBCHANNELS_PARAM,
-  LLM_DEFAULT_SESSION,
-} from './constants';
-import {ILLMChannel, DataChannelTokenType} from './llm.types';
+import {ILLMChannel} from './llm.types';
 
 export const config = {
   llm: {
@@ -48,287 +42,90 @@ export const config = {
  */
 export default class LLMChannel extends (Mercury as any) implements ILLMChannel {
   namespace = LLM;
-  defaultSessionId = LLM_DEFAULT_SESSION;
+
   /**
-   * Map to store connection-specific data for multiple LLM connections
-   * @private
-   * @type {Map<string, {webSocketUrl?: string; binding?: string; locusUrl?: string; datachannelUrl?: string}>}
+   * If the LLM plugin has been registered and listening
+   * @instance
+   * @type {Boolean}
+   * @public
    */
-  private connections: Map<
-    string,
-    {
-      webSocketUrl?: string;
-      binding?: string;
-      locusUrl?: string;
-      datachannelUrl?: string;
-      datachannelToken?: string;
-    }
-  > = new Map();
 
-  private datachannelTokens: Record<DataChannelTokenType, string> = {
-    [DataChannelTokenType.Default]: undefined,
-    [DataChannelTokenType.PracticeSession]: undefined,
-  };
+  private webSocketUrl?: string;
+
+  private binding?: string;
+
+  private locusUrl?: string;
 
-  private refreshHandler?: () => Promise<{
-    body: {datachannelToken: string; datachannelTokenType: DataChannelTokenType};
-  }>;
+  private datachannelUrl?: string;
 
   /**
    * Register to the websocket
    * @param {string} llmSocketUrl
-   * @param {string} datachannelToken
-   * @param {string} sessionId - Connection identifier
    * @returns {Promise<void>}
    */
-  private register = async (
-    llmSocketUrl: string,
-    datachannelToken?: string,
-    sessionId: string = LLM_DEFAULT_SESSION
-  ): Promise<void> => {
-    const isDataChannelTokenEnabled = await this.isDataChannelTokenEnabled();
-
-    return this.request({
+  private register = (llmSocketUrl: string): Promise<void> =>
+    this.request({
       method: 'POST',
       url: llmSocketUrl,
       body: {deviceUrl: this.webex.internal.device.url},
-      headers:
-        isDataChannelTokenEnabled && datachannelToken
-          ? {'Data-Channel-Auth-Token': datachannelToken}
-          : {},
     })
       .then((res: {body: {webSocketUrl: string; binding: string}}) => {
-        // Get or create connection data
-        const sessionData = this.connections.get(sessionId) || {};
-        sessionData.webSocketUrl = res.body.webSocketUrl;
-        sessionData.binding = res.body.binding;
-        this.connections.set(sessionId, sessionData);
+        this.webSocketUrl = res.body.webSocketUrl;
+        this.binding = res.body.binding;
       })
       .catch((error: any) => {
-        this.logger.error(`Error connecting to websocket for ${sessionId}: ${error}`);
+        this.logger.error(`Error connecting to websocket: ${error}`);
         throw error;
       });
-  };
 
   /**
    * Register and connect to the websocket
    * @param {string} locusUrl
    * @param {string} datachannelUrl
-   * @param {string} datachannelToken
-   * @param {string} sessionId - Connection identifier
    * @returns {Promise<void>}
    */
-  public registerAndConnect = (
-    locusUrl: string,
-    datachannelUrl: string,
-    datachannelToken?: string,
-    sessionId: string = LLM_DEFAULT_SESSION
-  ): Promise<void> =>
-    this.register(datachannelUrl, datachannelToken, sessionId).then(async () => {
+  public registerAndConnect = (locusUrl: string, datachannelUrl: string): Promise<void> =>
+    this.register(datachannelUrl).then(() => {
       if (!locusUrl || !datachannelUrl) return undefined;
-
-      // Get or create connection data
-      const sessionData = this.connections.get(sessionId) || {};
-      sessionData.locusUrl = locusUrl;
-      sessionData.datachannelUrl = datachannelUrl;
-      sessionData.datachannelToken = datachannelToken;
-      this.connections.set(sessionId, sessionData);
-
-      const isDataChannelTokenEnabled = await this.isDataChannelTokenEnabled();
-
-      const connectUrl = isDataChannelTokenEnabled
-        ? LLMChannel.buildUrlWithAwareSubchannels(sessionData.webSocketUrl, AWARE_DATA_CHANNEL)
-        : sessionData.webSocketUrl;
-
-      return this.connect(connectUrl, sessionId);
+      this.locusUrl = locusUrl;
+      this.datachannelUrl = datachannelUrl;
+      this.connect(this.webSocketUrl);
     });
 
   /**
    * Tells if LLM socket is connected
-   * @param {string} sessionId - Connection identifier
    * @returns {boolean} connected
    */
-  public isConnected = (sessionId = LLM_DEFAULT_SESSION): boolean => {
-    const socket = this.getSocket(sessionId);
-
-    return socket ? socket.connected : false;
-  };
+  public isConnected = (): boolean => this.connected;
 
   /**
    * Tells if LLM socket is binding
-   * @param {string} sessionId - Connection identifier
    * @returns {string} binding
    */
-  public getBinding = (sessionId = LLM_DEFAULT_SESSION): string => {
-    const sessionData = this.connections.get(sessionId);
-
-    return sessionData?.binding;
-  };
+  public getBinding = (): string => this.binding;
 
   /**
    * Get Locus URL for the connection
-   * @param {string} sessionId - Connection identifier
    * @returns {string} locus Url
    */
-  public getLocusUrl = (sessionId = LLM_DEFAULT_SESSION): string => {
-    const sessionData = this.connections.get(sessionId);
-
-    return sessionData?.locusUrl;
-  };
+  public getLocusUrl = (): string => this.locusUrl;
 
   /**
    * Get data channel URL for the connection
-   * @param {string} sessionId - Connection identifier
    * @returns {string} data channel Url
    */
-  public getDatachannelUrl = (sessionId = LLM_DEFAULT_SESSION): string => {
-    const sessionData = this.connections.get(sessionId);
-
-    return sessionData?.datachannelUrl;
-  };
-
-  /**
-   * Get data channel token for the connection
-   * @param {DataChannelTokenType} dataChannelTokenType
-   * @returns {string} data channel token
-   */
-  public getDatachannelToken = (
-    dataChannelTokenType: DataChannelTokenType = DataChannelTokenType.Default
-  ): string => {
-    return this.datachannelTokens[dataChannelTokenType];
-  };
-
-  /**
-   * Set data channel token for the connection
-   * @param {string} datachannelToken - data channel token
-   * @param {DataChannelTokenType} dataChannelTokenType
-   * @returns {void}
-   */
-  public setDatachannelToken = (
-    datachannelToken: string,
-    dataChannelTokenType: DataChannelTokenType = DataChannelTokenType.Default
-  ): void => {
-    this.datachannelTokens[dataChannelTokenType] = datachannelToken;
-  };
-
-  /**
-   * Resets all data‑channel tokens to their initial undefined values.
-   * Used when leaving or disconnecting from a meeting.
-   * @returns {void}
-   */
-  public resetDatachannelTokens() {
-    this.datachannelTokens = {
-      [DataChannelTokenType.Default]: undefined,
-      [DataChannelTokenType.PracticeSession]: undefined,
-    };
-  }
-
-  /**
-   * Set the handler used to refresh the DataChannel token
-   *
-   * @param {function} handler - Function that returns a refreshed token
-   * @returns {void}
-   */
-  public setRefreshHandler(
-    handler: () => Promise<{
-      body: {datachannelToken: string; datachannelTokenType: DataChannelTokenType};
-    }>
-  ) {
-    this.refreshHandler = handler;
-  }
-
-  /**
-   * Refresh the data channel token using the injected handler.
-   * Logs a descriptive error if the handler is missing or fails.
-   *
-   * @returns {Promise<string>} The refreshed token.
-   */
-  public async refreshDataChannelToken() {
-    if (!this.refreshHandler) {
-      this.logger.warn(
-        'llm#refreshDataChannelToken --> LLM refreshHandler is not set, skipping token refresh'
-      );
-
-      return null;
-    }
-
-    try {
-      const res = await this.refreshHandler();
-
-      return res;
-    } catch (error: any) {
-      this.logger.warn(
-        `llm#refreshDataChannelToken --> DataChannel token refresh failed (likely locus changed or participant left): ${
-          error?.message || error
-        }`
-      );
-
-      return null;
-    }
-  }
+  public getDatachannelUrl = (): string => this.datachannelUrl;
 
   /**
    * Disconnects websocket connection
    * @param {{code: number, reason: string}} options - The disconnect option object with code and reason
-   * @param {string} sessionId - Connection identifier
-   * @returns {Promise<void>}
-   */
-  public disconnectLLM = (
-    options: {code: number; reason: string},
-    sessionId: string = LLM_DEFAULT_SESSION
-  ): Promise<void> =>
-    this.disconnect(options, sessionId).then(() => {
-      // Clean up sessions data
-      this.connections.delete(sessionId);
-    });
-
-  /**
-   * Disconnects all LLM websocket connections
-   * @param {{code: number, reason: string}} options - The disconnect option object with code and reason
    * @returns {Promise<void>}
    */
-  public disconnectAllLLM = (options?: {code: number; reason: string}): Promise<void> =>
-    this.disconnectAll(options).then(() => {
-      // Clean up all connection data
-      this.connections.clear();
+  public disconnectLLM = (options: object): Promise<void> =>
+    this.disconnect(options).then(() => {
+      this.locusUrl = undefined;
+      this.datachannelUrl = undefined;
+      this.binding = undefined;
+      this.webSocketUrl = undefined;
     });
-
-  /**
-   * Get all active LLM connections
-   * @returns {Map} Map of sessionId to session data
-   */
-  public getAllConnections = (): Map<
-    string,
-    {
-      webSocketUrl?: string;
-      binding?: string;
-      locusUrl?: string;
-      datachannelUrl?: string;
-      datachannelToken?: string;
-    }
-  > => new Map(this.connections);
-
-  /**
-   * Returns true if  data channel token is enabled, false otherwise
-   * @returns {Promise<boolean>} resolves with true if data channel token  is enabled
-   */
-  public isDataChannelTokenEnabled(): Promise<boolean> {
-    // @ts-ignore
-    return this.webex.internal.feature.getFeature('developer', DATA_CHANNEL_WITH_JWT_TOKEN);
-  }
-
-  /**
-   * Builds a WebSocket URL with the `subscriptionAwareSubchannels` query parameter.
-   *
-   * @param {string} baseUrl - The original WebSocket URL.
-   * @param {string[]} subchannels - List of subchannels to declare as subscription-aware.
-   * @returns {string} The final URL with updated query parameters.
-   */
-
-  public static buildUrlWithAwareSubchannels = (baseUrl: string, subchannels: string[]) => {
-    const urlObj = new URL(baseUrl);
-    urlObj.searchParams.set(SUBSCRIPTION_AWARE_SUBCHANNELS_PARAM, subchannels.join(','));
-
-    return urlObj.toString();
-  };
 }

package/src/llm.types.ts

@@ -1,32 +1,9 @@
 interface ILLMChannel {
-  registerAndConnect: (
-    locusUrl: string,
-    datachannelUrl: string,
-    datachannelToken?: string,
-    sessionId?: string
-  ) => Promise<void>;
-  isConnected: (sessionId?: string) => boolean;
-  getBinding: (sessionId?: string) => string;
-  getLocusUrl: (sessionId?: string) => string;
-  getDatachannelUrl: (sessionId?: string) => string;
-  disconnectLLM: (options: {code: number; reason: string}, sessionId?: string) => Promise<void>;
-  disconnectAllLLM: (options?: {code: number; reason: string}) => Promise<void>;
-  getAllConnections: () => Map<
-    string,
-    {
-      webSocketUrl?: string;
-      binding?: string;
-      locusUrl?: string;
-      datachannelUrl?: string;
-      datachannelToken?: string;
-    }
-  >;
+  registerAndConnect: (locusUrl: string, datachannelUrl: string) => Promise<void>;
+  isConnected: () => boolean;
+  getBinding: () => string;
+  getLocusUrl: () => string;
+  disconnectLLM: (options: {code: number; reason: string}) => Promise<void>;
 }
-
-export enum DataChannelTokenType {
-  Default = 'llm-default-session',
-  PracticeSession = 'llm-practice-session',
-}
-
 // eslint-disable-next-line import/prefer-default-export
 export type {ILLMChannel};