@webex/contact-center 3.11.0 → 3.12.0-mobius-socket.2

package/src/services/config/index.ts

@@ -22,6 +22,7 @@ import {
   SiteInfo,
   OutdialAniEntriesResponse,
   OutdialAniParams,
+  AIFeatureFlagsResponse,
 } from './types';
 import WebexRequest from '../core/WebexRequest';
 import {WCC_API_GATEWAY} from '../constants';
@@ -61,6 +62,7 @@ export default class AgentConfigService {
       const orgSettingsPromise = this.getOrganizationSetting(orgId);
       const tenantDataPromise = this.getTenantData(orgId);
       const urlMappingPromise = this.getURLMapping(orgId);
+      const aiFeatureFlagsPromise = this.getAIFeatureFlags(orgId);
       const auxCodesPromise = this.getAllAuxCodes(
         orgId,
         DEFAULT_PAGE_SIZE,
@@ -94,6 +96,7 @@ export default class AgentConfigService {
         orgSettingsData,
         tenantData,
         urlMappingData,
+        aiFeatureFlagsData,
         auxCodesData,
       ] = await Promise.all([
         agentProfilePromise,
@@ -104,9 +107,9 @@ export default class AgentConfigService {
         orgSettingsPromise,
         tenantDataPromise,
         urlMappingPromise,
+        aiFeatureFlagsPromise,
         auxCodesPromise,
       ]);
-
       const multimediaProfileId =
         userConfigData.multimediaProfileId ||
         userTeamData[0]?.multiMediaProfileId ||
@@ -128,6 +131,7 @@ export default class AgentConfigService {
         dialPlanData: userDialPlanData,
         urlMapping: urlMappingData,
         multimediaProfileId,
+        aiFeatureFlags: aiFeatureFlagsData,
       });
 
       LoggerProxy.info('Parsing completed for agent-config', {
@@ -651,6 +655,46 @@ export default class AgentConfigService {
     }
   }
 
+  /**
+   * Fetches AI feature resources for the organization.
+   * @ignore
+   * @param {string} orgId - organization ID for which AI feature resources are to be fetched.
+   * @returns {Promise<AIFeatureFlagsResponse>} - AI feature resources response.
+   * @throws {Error} - Throws an error if the API call fails or if the response status is not 200.
+   * @private
+   */
+  public async getAIFeatureFlags(orgId: string): Promise<AIFeatureFlagsResponse> {
+    LoggerProxy.info('Fetching AI feature resources', {
+      module: CONFIG_FILE_NAME,
+      method: METHODS.GET_AI_FEATURE_FLAGS,
+    });
+    try {
+      const resource = endPointMap.aiFeature(orgId);
+      const response = await this.webexReq.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.GET,
+      });
+
+      if (response.statusCode !== 200) {
+        throw new Error(`API call failed with ${response.statusCode}`);
+      }
+
+      LoggerProxy.log('getAIFeatureFlags api success.', {
+        module: CONFIG_FILE_NAME,
+        method: METHODS.GET_AI_FEATURE_FLAGS,
+      });
+
+      return Promise.resolve(response.body);
+    } catch (error) {
+      LoggerProxy.error(`getAIFeatureFlags API call failed with ${error}`, {
+        module: CONFIG_FILE_NAME,
+        method: METHODS.GET_AI_FEATURE_FLAGS,
+      });
+      throw error;
+    }
+  }
+
   /**
    * Fetches the dial plan data for the given orgId.
    * @ignore

package/src/services/config/types.ts

@@ -111,6 +111,14 @@ export const CC_TASK_EVENTS = {
   AGENT_CONTACT_UNASSIGNED: 'AgentContactUnassigned',
   /** Event emitted when inviting agent fails */
   AGENT_INVITE_FAILED: 'AgentInviteFailed',
+  /** Event emitted when a campaign preview contact is offered to the agent */
+  AGENT_OFFER_CAMPAIGN_RESERVATION: 'AgentOfferCampaignReservation',
+  /** Event emitted when campaign contact is updated */
+  CAMPAIGN_CONTACT_UPDATED: 'CampaignContactUpdated',
+  /** Event emitted when accepting a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'CampaignPreviewAcceptFailed',
+  /** Event emitted when a real-time transcript chunk is received */
+  REAL_TIME_TRANSCRIPTION: 'REAL_TIME_TRANSCRIPTION',
 } as const;
 
 /**
@@ -580,6 +588,8 @@ export type OrgInfo = {
   tenantId: string;
   /** Organization timezone */
   timezone: string;
+  /** Current environment (e.g., 'produs1', 'intgus1') */
+  environment: string;
 };
 
 /**
@@ -900,6 +910,59 @@ export type URLMappings = {
   acqueonConsoleUrl: string;
 };
 
+/**
+ * AI feature resource row returned by /v2/ai-feature API.
+ * @public
+ */
+export type AIFeatureFlags = {
+  id: string;
+  realtimeTranscripts?: {
+    enable?: boolean;
+    agentInclusionType?: string;
+  };
+  suggestedResponses?: {
+    enable?: boolean;
+  };
+  generatedSummaries?: {
+    callDropSummariesEnabled?: boolean;
+    virtualAgentTransferSummariesEnabled?: boolean;
+    consultTransferSummariesEnabled?: boolean;
+    wrapUpSummariesEnabled?: boolean;
+    queuesInclusionType?: string;
+  };
+  agentWellbeing?: {
+    enable?: boolean;
+    agentInclusionType?: string;
+    wellnessBreakReminders?: string;
+  };
+  autoCSAT?: {
+    enable?: boolean;
+    queuesInclusionType?: string;
+    surveyDataSource?: string;
+  };
+  links?: string[];
+  createdTime?: number;
+  lastUpdatedTime?: number;
+};
+
+/**
+ * Response type for list AI feature resources API.
+ * @public
+ */
+export type AIFeatureFlagsResponse = {
+  meta?: {
+    orgid?: string;
+    page?: number;
+    pageSize?: number;
+    totalPages?: number;
+    totalRecords?: number;
+    links?: {
+      self?: string;
+    };
+  };
+  data: AIFeatureFlags[];
+};
+
 /**
  * Comprehensive agent profile configuration in the contact center system
  * Contains all settings and capabilities for an agent
@@ -1031,6 +1094,8 @@ export type Profile = {
   isAnalyzerEnabled?: boolean;
   /** Tenant timezone */
   tenantTimezone?: string;
+  /** Current environment (e.g., 'produs1', 'intgus1') */
+  environment?: string;
   /** Available voice login options */
   loginVoiceOptions?: LoginOption[];
   /** Current login device type */
@@ -1055,6 +1120,8 @@ export type Profile = {
   lastStateChangeTimestamp?: number;
   /** Timestamp of last idle code change */
   lastIdleCodeChangeTimestamp?: number;
+  /** AI feature flags resolved from organization config */
+  aiFeature?: AIFeatureFlags;
 };
 
 /**

package/src/services/constants.ts

@@ -59,6 +59,14 @@ export const AGENT = 'agent';
  */
 export const SUBSCRIBE_API = 'v1/notification/subscribe';
 
+/**
+ * API path for realtime transcription subscription.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export const RTD_SUBSCRIBE_API = 'v1/realtime/subscribe';
+
 /**
  * API path for agent login.
  * @type {string}
@@ -109,3 +117,24 @@ export const METHODS = {
   MAP_CALL_TO_TASK: 'mapCallToTask',
   GET_TASK_ID_FOR_CALL: 'getTaskIdForCall',
 };
+
+export const AI_ASSISTANT_API_URLS = {
+  EVENT: '/event',
+  TRANSCRIPTS_LIST: '/transcripts/list',
+};
+
+export const AI_ASSISTANT_BASE_URL_TEMPLATE = 'https://api-ai-assistant.%s.ciscoccservice.com';
+
+export const AI_ASSISTANT_ENV_MAP: Record<string, string> = {
+  'api.intgus1.ciscoccservice.com': 'intgus1',
+  'api.qaus1.ciscoccservice.com': 'qaus1',
+  'api.wxcc-us1.cisco.com': 'produs1',
+  'api.wxcc-eu1.cisco.com': 'prodeu1',
+  'api.wxcc-eu2.cisco.com': 'prodeu2',
+  'api.wxcc-anz1.cisco.com': 'prodanz1',
+  'api.wxcc-ca1.cisco.com': 'prodca1',
+  'api.wxcc-jp1.cisco.com': 'prodjp1',
+  'api.wxcc-sg1.cisco.com': 'prodsg1',
+  'api.wxcc-in1.cisco.com': 'prodin1',
+  'api.loadus1.cisco.com': 'loadus1',
+};

package/src/services/core/Err.ts

@@ -38,6 +38,7 @@ export type TaskErrorIds =
   | {'Service.aqm.task.pauseRecording': Failure}
   | {'Service.aqm.task.resumeRecording': Failure}
   | {'Service.aqm.dialer.startOutdial': Failure}
+  | {'Service.aqm.dialer.acceptPreviewContact': Failure}
   | {'Service.reqs.generic.failure': {trackingId: string}};
 
 export type ReqError =

package/src/services/core/Utils.ts

@@ -10,6 +10,7 @@ import {
   Interaction,
 } from '../task/types';
 import {PARTICIPANT_TYPES, STATE_CONSULT} from './constants';
+import {DialPlan} from '../config/types';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -48,11 +49,37 @@ const getAgentActionTypeFromTask = (taskData?: TaskData): 'DIAL_NUMBER' | '' =>
   return isDialNumber || isEntryPointVariant ? 'DIAL_NUMBER' : '';
 };
 
-export const isValidDialNumber = (input: string): boolean => {
-  // This regex checks for a valid dial number format for only few countries such as US, Canada.
-  const regexForDn = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
+// Fallback regex for US/Canada dial numbers when no dial plan entries are configured
+export const FALLBACK_DIAL_NUMBER_REGEX = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
 
-  return regexForDn.test(input);
+/**
+ * Validates a dial number against the provided dial plan regex patterns.
+ * A number is valid if it matches at least one regex pattern in the dial plans.
+ * Falls back to US/Canada regex validation if no dial plan entries are configured.
+ *
+ * @param input - The dial number to validate
+ * @param dialPlanEntries - Array of dial plan entries containing regex patterns
+ * @returns true if the input matches at least one dial plan regex pattern, false otherwise
+ */
+export const isValidDialNumber = (
+  input: string,
+  dialPlanEntries: DialPlan['dialPlanEntity']
+): boolean => {
+  if (!dialPlanEntries || dialPlanEntries.length === 0) {
+    LoggerProxy.info('No dial plan entries found. Falling back to US number validation.');
+
+    return FALLBACK_DIAL_NUMBER_REGEX.test(input);
+  }
+
+  return dialPlanEntries.some((entry) => {
+    try {
+      const regex = new RegExp(entry.regex);
+
+      return regex.test(input);
+    } catch {
+      return false;
+    }
+  });
 };
 
 export const getStationLoginErrorData = (failure: Failure, loginOption: LoginOption) => {
@@ -74,7 +101,7 @@ export const getStationLoginErrorData = (failure: Failure, loginOption: LoginOpt
     },
     INVALID_DIAL_NUMBER: {
       message:
-        'Enter a valid US dial number. For help, reach out to your administrator or support team.',
+        'Enter a valid dial number. For help, reach out to your administrator or support team.',
       fieldName: loginOption,
     },
   };

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) {

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/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 realtime 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);