Feat/webinar llm latencies 2

packages/@webex/internal-plugin-llm/src/index.ts

@@ -2,6 +2,8 @@ import * as WebexCore from '@webex/webex-core';
 import LLMChannel, {config} from './llm';
 import {DataChannelTokenType} from './llm.types';
 
+export type {RegisterAndConnectTiming} from './llm.types';
+
 WebexCore.registerInternalPlugin('llm', LLMChannel, {
   config,
 });

packages/@webex/internal-plugin-llm/src/llm.ts

@@ -10,7 +10,7 @@ import {
   SUBSCRIPTION_AWARE_SUBCHANNELS_PARAM,
   LLM_DEFAULT_SESSION,
 } from './constants';
-import {ILLMChannel, DataChannelTokenType} from './llm.types';
+import {ILLMChannel, DataChannelTokenType, RegisterAndConnectTiming} from './llm.types';
 
 export const config = {
   llm: {
@@ -125,7 +125,9 @@ export default class LLMChannel extends (Mercury as any) implements ILLMChannel
     datachannelUrl: string,
     datachannelToken?: string,
     sessionId: string = LLM_DEFAULT_SESSION
-  ): Promise<void> => {
+  ): Promise<RegisterAndConnectTiming | undefined> => {
+    const registerStart = performance.now();
+
     // Pre-populate locusUrl and datachannelUrl before register() fires the
     // HTTP POST, so that any token refresh triggered during registration can
     // be routed via connections without falling back to a locusInfo URL scan.
@@ -139,18 +141,30 @@ export default class LLMChannel extends (Mercury as any) implements ILLMChannel
     return this.register(datachannelUrl, datachannelToken, sessionId).then(async () => {
       if (!locusUrl || !datachannelUrl) return undefined;
 
+      const clientLLMDatachannelResponseTime = Math.round(performance.now() - registerStart);
+
       // locusUrl and datachannelUrl were pre-populated before register(); here
       // we only need to read the existing session data to get webSocketUrl/binding
       // that register() filled in.
       const sessionData = this.connections.get(sessionId) || {};
 
+      if (!sessionData.webSocketUrl) {
+        return undefined;
+      }
+
       const isDataChannelTokenEnabled = await this.isDataChannelTokenEnabled();
 
       const connectUrl = isDataChannelTokenEnabled
         ? LLMChannel.buildUrlWithAwareSubchannels(sessionData.webSocketUrl, AWARE_DATA_CHANNEL)
         : sessionData.webSocketUrl;
 
-      return this.connect(connectUrl, sessionId);
+      const connectStart = performance.now();
+
+      await this.connect(connectUrl, sessionId);
+
+      const clientLLMWebSocketConnectTime = Math.round(performance.now() - connectStart);
+
+      return {clientLLMDatachannelResponseTime, clientLLMWebSocketConnectTime};
     });
   };
 
@@ -198,6 +212,17 @@ export default class LLMChannel extends (Mercury as any) implements ILLMChannel
     return sessionData?.datachannelUrl;
   };
 
+  /**
+   * Get WebSocket URL for the connection
+   * @param {string} sessionId - Connection identifier
+   * @returns {string | undefined} WebSocket URL
+   */
+  public getWebSocketUrl = (sessionId = LLM_DEFAULT_SESSION): string | undefined => {
+    const sessionData = this.connections.get(sessionId);
+
+    return sessionData?.webSocketUrl;
+  };
+
   /**
    * Set the owner meeting ID for a given LLM session. Used by the meetings
    * plugin to tag which Meeting instance currently owns the (default) LLM

packages/@webex/internal-plugin-llm/src/llm.types.ts

@@ -5,17 +5,26 @@ export enum DataChannelTokenType {
 
 type DataChannelTokenKey = DataChannelTokenType | string;
 
+/**
+ * Latencies (in milliseconds) captured during register + websocket connect.
+ */
+type RegisterAndConnectTiming = {
+  clientLLMDatachannelResponseTime?: number;
+  clientLLMWebSocketConnectTime?: number;
+};
+
 interface ILLMChannel {
   registerAndConnect: (
     locusUrl: string,
     datachannelUrl: string,
     datachannelToken?: string,
     sessionId?: string
-  ) => Promise<void>;
+  ) => Promise<RegisterAndConnectTiming | undefined>;
   isConnected: (sessionId?: string) => boolean;
   getBinding: (sessionId?: string) => string;
   getLocusUrl: (sessionId?: string) => string;
   getDatachannelUrl: (sessionId?: string) => string;
+  getWebSocketUrl: (sessionId?: string) => string | undefined;
   disconnectLLM: (
     options: {code: number; reason: string},
     sessionId?: string,
@@ -66,4 +75,4 @@ interface ILLMChannel {
 }
 
 // eslint-disable-next-line import/prefer-default-export
-export type {ILLMChannel, DataChannelTokenKey};
+export type {ILLMChannel, DataChannelTokenKey, RegisterAndConnectTiming};

packages/@webex/internal-plugin-llm/test/unit/spec/llm.js

@@ -709,5 +709,75 @@ describe('plugin-llm', () => {
       });
     });
 
+    describe('#registerAndConnect timing', () => {
+      it('returns timing data on successful connection', async () => {
+        const clock = sinon.useFakeTimers();
+
+        llmService.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+        llmService.register = sinon.stub().callsFake(() => {
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              const sessionData = llmService.connections.get('llm-default-session') || {};
+
+              sessionData.webSocketUrl = 'wss://example.com/socket';
+              sessionData.binding = 'binding';
+              llmService.connections.set('llm-default-session', sessionData);
+
+              resolve();
+            }, 37);
+          });
+        });
+        llmService.connect = sinon.stub().callsFake(() => {
+          return new Promise((resolve) => {
+            setTimeout(resolve, 23);
+          });
+        });
+
+        const resultPromise = llmService.registerAndConnect(locusUrl, datachannelUrl, undefined);
+
+        await clock.tickAsync(37);
+        await clock.tickAsync(23);
+
+        const result = await resultPromise;
+
+        assert.deepEqual(result, {
+          clientLLMDatachannelResponseTime: 37,
+          clientLLMWebSocketConnectTime: 23,
+        });
+      });
+
+      it('returns undefined when locusUrl is empty', async () => {
+        llmService.register = sinon.stub().resolves();
+
+        const result = await llmService.registerAndConnect('', datachannelUrl, undefined);
+
+        assert.isUndefined(result);
+      });
+    });
+
+    describe('#getWebSocketUrl', () => {
+      it('returns the websocket URL for default session', () => {
+        llmService.connections.set('llm-default-session', {
+          webSocketUrl: 'wss://test.example.com/ws',
+        });
+
+        assert.equal(llmService.getWebSocketUrl(), 'wss://test.example.com/ws');
+      });
+
+      it('returns undefined when no connection exists', () => {
+        llmService.connections.clear();
+
+        assert.isUndefined(llmService.getWebSocketUrl());
+      });
+
+      it('returns the websocket URL for custom session', () => {
+        llmService.connections.set('custom-session', {
+          webSocketUrl: 'wss://custom.example.com/ws',
+        });
+
+        assert.equal(llmService.getWebSocketUrl('custom-session'), 'wss://custom.example.com/ws');
+      });
+    });
+
   });
 });