@webex/contact-center 3.11.0 → 3.12.0-llmrefactor.2

package/src/services/core/aqm-reqs.ts

@@ -20,18 +20,40 @@ export default class AqmReqs {
     this.webSocketManager.on('message', this.onMessage.bind(this));
   }
 
+  /**
+   * Creates a request function for an API call with parameters
+   * @param c - The configuration for the request
+   * @returns A function that makes the API request
+   */
   req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq> {
     return (p: TReq, cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(p), cbRes);
   }
 
+  /**
+   * Creates a request function for an API call with no parameters
+   * @param c - The configuration for the request
+   * @returns A function that makes the API request
+   */
   reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes> {
     return (cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(), cbRes);
   }
 
+  /**
+   * Makes an API request
+   * @param c - The request configuration
+   * @param cbRes - The callback for the response
+   * @returns A promise that resolves with the response or rejects with an error
+   */
   private async makeAPIRequest<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>): Promise<TRes> {
     return this.createPromise(c, cbRes);
   }
 
+  /**
+   * Creates a promise for an API request
+   * @param c - The request configuration
+   * @param cbRes - The callback for the response
+   * @returns A promise that resolves with the response or rejects with an error
+   */
   private createPromise<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>) {
     return new Promise<TRes>((resolve, reject) => {
       const keySuccess = this.bindPrint(c.notifSuccess.bind);
@@ -154,10 +176,13 @@ export default class AqmReqs {
             if (response?.headers) {
               response.headers.Authorization = '*';
             }
-            LoggerProxy.error(`Routing request timeout${keySuccess}${response!}${c.url}`, {
-              module: AQM_REQS_FILE,
-              method: METHODS.CREATE_PROMISE,
-            });
+            LoggerProxy.error(
+              `Routing request timeout${keySuccess}${JSON.stringify(response)}${c.url}`,
+              {
+                module: AQM_REQS_FILE,
+                method: METHODS.CREATE_PROMISE,
+              }
+            );
             reject(
               new Err.Details('Service.aqm.reqs.Timeout', {
                 key: keySuccess,
@@ -171,39 +196,60 @@ export default class AqmReqs {
     });
   }
 
-  private bindPrint(bind: any) {
+  /**
+   * Converts a bind object to a string representation
+   * @param bind - The bind object to convert
+   * @returns A string representation of the bind object
+   */
+  private bindPrint(bind: any): string {
     let result = '';
-    // eslint-disable-next-line no-restricted-syntax
-    for (const k in bind) {
-      if (Array.isArray(bind[k])) {
-        result += `${k}=[${bind[k].join(',')}],`;
-      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
-        result += `${k}=(${this.bindPrint(bind[k])}),`;
+    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
+      const value = bind[key];
+
+      if (Array.isArray(value)) {
+        result += `${key}=[${value.join(',')}],`;
+      } else if (typeof value === 'object' && value !== null) {
+        result += `${key}=(${this.bindPrint(value)}),`;
       } else {
-        result += `${k}=${bind[k]},`;
+        result += `${key}=${value},`;
       }
     }
 
     return result ? result.slice(0, -1) : result;
   }
 
-  private bindCheck(bind: any, msg: any) {
-    // eslint-disable-next-line no-restricted-syntax
-    for (const k in bind) {
-      if (Array.isArray(bind[k])) {
+  /**
+   * Checks if a message matches a bind object
+   * @param bind - The bind object to check against
+   * @param msg - The message to check
+   * @returns True if the message matches the bind object, false otherwise
+   */
+  private bindCheck(bind: any, msg: any): boolean {
+    // Handle type-dependent field matching if __typeMap is present
+    if (bind.__typeMap && typeof bind.__typeMap === 'object') {
+      if (!AqmReqs.typeMapCheck(bind.__typeMap, msg)) {
+        return false;
+      }
+    }
+
+    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
+      const bindValue = bind[key];
+      const msgValue = msg[key];
+
+      if (Array.isArray(bindValue)) {
         // Check if the message value matches any of the values in the array
-        if (!bind[k].includes(msg[k])) {
+        if (!bindValue.includes(msgValue)) {
           return false;
         }
-      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
-        if (typeof msg[k] === 'object' && msg[k] !== null) {
-          if (!this.bindCheck(bind[k], msg[k])) {
+      } else if (typeof bindValue === 'object' && bindValue !== null) {
+        if (typeof msgValue === 'object' && msgValue !== null) {
+          if (!this.bindCheck(bindValue, msgValue)) {
             return false;
           }
         } else {
           return false;
         }
-      } else if (!msg[k] || msg[k] !== bind[k]) {
+      } else if (!msgValue || msgValue !== bindValue) {
         return false;
       }
     }
@@ -211,7 +257,39 @@ export default class AqmReqs {
     return true;
   }
 
-  // must be lambda
+  /**
+   * Checks type-dependent field conditions defined in __typeMap.
+   * @param typeMap - The type map to check against
+   * @param msg - The message to check
+   * @returns True if the message matches the type map, false otherwise
+   * The typeMap has the shape:
+   *   { typeField: "type", conditions: { EventA: { field: value }, EventB: { field: value } } }
+   * It reads msg[typeField] to determine which condition set to apply,
+   * then verifies all fields in that condition match the message.
+   */
+  private static typeMapCheck(typeMap: any, msg: any): boolean {
+    const typeField = typeMap.typeField || 'type';
+    const msgType = msg[typeField];
+
+    if (typeMap.conditions && typeMap.conditions[msgType]) {
+      const condition = typeMap.conditions[msgType];
+      for (const field of Object.keys(condition)) {
+        if (!msg[field] || msg[field] !== condition[field]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Handles incoming messages from the WebSocket (must be a lambda fn)
+   * @param msg - The message to handle
+   * @returns
+   */
   private readonly onMessage = (msg: any) => {
     const event = JSON.parse(msg);
     if (event.type === 'Welcome') {

package/src/services/core/websocket/WebSocketManager.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import {WebexSDK, SubscribeRequest, HTTP_METHODS} from '../../../types';
-import {SUBSCRIBE_API, WCC_API_GATEWAY} from '../../constants';
+import {WCC_API_GATEWAY} from '../../constants';
 import {ConnectionLostDetails} from './types';
 import {CC_EVENTS, SubscribeResponse, WelcomeResponse} from '../../config/types';
 import LoggerProxy from '../../../logger-proxy';
@@ -44,10 +44,13 @@ export class WebSocketManager extends EventEmitter {
     this.keepaliveWorker = new Worker(URL.createObjectURL(workerScriptBlob));
   }
 
-  async initWebSocket(options: {body: SubscribeRequest}): Promise<WelcomeResponse> {
-    const connectionConfig = options.body;
+  async initWebSocket(options: {
+    body: SubscribeRequest;
+    resource: string;
+  }): Promise<WelcomeResponse> {
+    const {body: connectionConfig, resource} = options;
     try {
-      await this.register(connectionConfig);
+      await this.register(connectionConfig, resource);
     } catch (error) {
       LoggerProxy.error(`[WebSocketStatus] | Error in registering Websocket ${error}`, {
         module: WEB_SOCKET_MANAGER_FILE,
@@ -84,13 +87,25 @@ export class WebSocketManager extends EventEmitter {
     this.isConnectionLost = event.isConnectionLost;
   }
 
-  private async register(connectionConfig: SubscribeRequest) {
+  private async register(connectionConfig: SubscribeRequest, resource: string) {
     try {
+      // X-ORGANIZATION-ID header is only required for INT environments
+      const isIntEnv = this.webex.internal?.services?.isIntegrationEnvironment() || false;
+      const orgId = this.webex.credentials.getOrgId();
+
+      if (isIntEnv && orgId) {
+        LoggerProxy.log(`[WebSocketManager] Adding X-ORGANIZATION-ID header for INT environment`, {
+          module: WEB_SOCKET_MANAGER_FILE,
+          method: METHODS.REGISTER,
+        });
+      }
+
       const subscribeResponse: SubscribeResponse = await this.webex.request({
         service: WCC_API_GATEWAY,
-        resource: SUBSCRIBE_API,
+        resource,
         method: HTTP_METHODS.POST,
         body: connectionConfig,
+        headers: isIntEnv && orgId ? {'X-ORGANIZATION-ID': orgId} : undefined,
       });
       this.url = subscribeResponse.body.webSocketUrl;
     } catch (e) {
@@ -199,3 +214,5 @@ export class WebSocketManager extends EventEmitter {
     }
   }
 }
+
+export default WebSocketManager;

package/src/services/core/websocket/connection-service.ts

@@ -10,6 +10,7 @@ import {
 } from '../constants';
 import {CONNECTION_SERVICE_FILE} from '../../../constants';
 import {SubscribeRequest} from '../../../types';
+import {SUBSCRIBE_API} from '../../constants';
 
 export class ConnectionService extends EventEmitter {
   private connectionProp: ConnectionProp = {
@@ -124,7 +125,10 @@ export class ConnectionService extends EventEmitter {
     });
     const onlineStatus = navigator.onLine;
     if (onlineStatus) {
-      await this.webSocketManager.initWebSocket({body: this.subscribeRequest});
+      await this.webSocketManager.initWebSocket({
+        body: this.subscribeRequest,
+        resource: SUBSCRIBE_API,
+      });
       await this.clearTimerOnRestoreFailed();
       this.isSocketReconnected = true;
     } else {

package/src/services/core/websocket/types.ts

@@ -1,5 +1,5 @@
 import {SubscribeRequest} from '../../../types';
-import {WebSocketManager} from './WebSocketManager';
+import type WebSocketManager from './WebSocketManager';
 
 /**
  * Options for initializing a connection service.

package/src/services/index.ts

@@ -25,6 +25,8 @@ export default class Services {
   public readonly dialer: ReturnType<typeof aqmDialer>;
   /** WebSocket manager for handling real-time communications */
   public readonly webSocketManager: WebSocketManager;
+  /** RTD WebSocket manager for handling real-time transcription */
+  public readonly rtdWebSocketManager: WebSocketManager;
   /** Connection service for managing websocket connections */
   public readonly connectionService: ConnectionService;
   /** Singleton instance of the Services class */
@@ -39,6 +41,8 @@ export default class Services {
   constructor(options: {webex: WebexSDK; connectionConfig: SubscribeRequest}) {
     const {webex, connectionConfig} = options;
     this.webSocketManager = new WebSocketManager({webex});
+    // TODO: Implement reconnection logic for this websocket in upcoming PR
+    this.rtdWebSocketManager = new WebSocketManager({webex});
     const aqmReq = new AqmReqs(this.webSocketManager);
     this.config = new AgentConfigService();
     this.agent = routingAgent(aqmReq);