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

package/src/cc.ts

@@ -39,7 +39,7 @@ import {
   METHODS,
 } from './constants';
 import {AGENT_STATE_AVAILABLE, AGENT_STATE_AVAILABLE_ID} from './services/config/constants';
-import {AGENT, WEB_RTC_PREFIX} from './services/constants';
+import {AGENT, RTD_SUBSCRIBE_API, SUBSCRIBE_API, WEB_RTC_PREFIX} from './services/constants';
 import Services from './services';
 import WebexRequest from './services/core/WebexRequest';
 import LoggerProxy from './logger-proxy';
@@ -55,13 +55,20 @@ import {
 import {ConnectionLostDetails} from './services/core/websocket/types';
 import TaskManager from './services/task/TaskManager';
 import WebCallingService from './services/WebCallingService';
-import {ITask, TASK_EVENTS, TaskResponse, DialerPayload} from './services/task/types';
+import {
+  ITask,
+  TASK_EVENTS,
+  TaskResponse,
+  DialerPayload,
+  PreviewContactPayload,
+} from './services/task/types';
 import MetricsManager from './metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from './metrics/constants';
 import {Failure} from './services/core/GlobalTypes';
-import EntryPoint from './services/EntryPoint';
-import AddressBook from './services/AddressBook';
-import Queue from './services/Queue';
+import {EntryPoint} from './services/EntryPoint';
+import {AddressBook} from './services/AddressBook';
+import {Queue} from './services/Queue';
+import {ApiAIAssistant} from './services/ApiAiAssistant';
 import type {
   EntryPointListResponse,
   EntryPointSearchParams,
@@ -119,6 +126,7 @@ import type {
  *   - `task:established` - Task/call has been connected
  *   - `task:ended` - Task/call has ended
  *   - `task:error` - An error occurred during task handling
+ *   - `task:campaignPreviewReservation` - Campaign preview contact offered to agent
  *
  * @public
  *
@@ -319,6 +327,13 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    */
   private queue: Queue;
 
+  /**
+   * API instance for AI Assistant operations such as transcript controls.
+   * @type {ApiAIAssistant}
+   * @public
+   */
+  public apiAIAssistant: ApiAIAssistant;
+
   /**
    * Logger utility for Contact Center plugin
    * Provides consistent logging across the plugin
@@ -357,8 +372,10 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.services.webSocketManager.on('message', this.handleWebsocketMessage);
 
       this.webCallingService = new WebCallingService(this.$webex);
+      this.apiAIAssistant = new ApiAIAssistant(this.$webex);
       this.metricsManager = MetricsManager.getInstance({webex: this.$webex});
       this.taskManager = TaskManager.getTaskManager(
+        this.apiAIAssistant,
         this.services.contact,
         this.webCallingService,
         this.services.webSocketManager
@@ -370,8 +387,6 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.entryPoint = new EntryPoint(this.$webex);
       this.addressBook = new AddressBook(this.$webex, () => this.agentConfig?.addressBookId);
       this.queue = new Queue(this.$webex);
-
-      // Initialize logger
       LoggerProxy.initialize(this.$webex.logger);
     });
   }
@@ -406,6 +421,20 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.trigger(TASK_EVENTS.TASK_MERGED, task);
   };
 
+  /**
+   * Handles campaign preview reservation events when a contact is offered to the agent
+   * @private
+   * @param {ITask} task The campaign reservation task
+   */
+  private handleCampaignPreviewReservation = (task: ITask) => {
+    // @ts-ignore
+    this.trigger(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
+  };
+
+  private handleRTDWebsocketMessage = (payload: string) => {
+    this.taskManager.handleRealtimeWebsocketEvent(payload);
+  };
+
   /**
    * Sets up event listeners for incoming tasks and task hydration
    * Subscribes to task events from the task manager
@@ -415,6 +444,10 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.taskManager.on(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
     this.taskManager.on(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
     this.taskManager.on(TASK_EVENTS.TASK_MERGED, this.handleTaskMerged);
+    this.taskManager.on(
+      TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+      this.handleCampaignPreviewReservation
+    );
   }
 
   /**
@@ -543,9 +576,14 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
       this.taskManager.off(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
       this.taskManager.off(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+      this.taskManager.off(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+        this.handleCampaignPreviewReservation
+      );
       this.taskManager.unregisterIncomingCallEvent();
 
       this.services.webSocketManager.off('message', this.handleWebsocketMessage);
+      this.services.rtdWebSocketManager.off('message', this.handleRTDWebsocketMessage);
       this.services.connectionService.off('connectionLost', this.handleConnectionLost);
 
       if (
@@ -569,6 +607,10 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         this.services.webSocketManager.close(false, 'Unregistering the SDK');
       }
 
+      if (this.services.rtdWebSocketManager && !this.services.rtdWebSocketManager.isSocketClosed) {
+        this.services.rtdWebSocketManager.close(false, 'Unregistering the RTD websocket');
+      }
+
       // Clear any cached agent configuration
       this.agentConfig = null;
 
@@ -697,6 +739,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     try {
       const data = (await this.services.webSocketManager.initWebSocket({
         body: this.getConnectionConfig(),
+        resource: SUBSCRIBE_API,
       })) as WelcomeEvent;
 
       const agentId = data.agentId;
@@ -712,6 +755,33 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.taskManager.setWrapupData(this.agentConfig.wrapUpData);
       this.taskManager.setAgentId(this.agentConfig.agentId);
       this.taskManager.setWebRtcEnabled(this.agentConfig.webRtcEnabled);
+      this.apiAIAssistant.setAIFeatureFlags(this.agentConfig.aiFeature);
+
+      if (this.agentConfig.aiFeature?.realtimeTranscripts?.enable) {
+        LoggerProxy.info('Connecting to RTD websocket', {
+          module: CC_FILE,
+          method: METHODS.CONNECT_WEBSOCKET,
+        });
+
+        await this.services.rtdWebSocketManager
+          .initWebSocket({
+            body: this.getConnectionConfig(),
+            resource: RTD_SUBSCRIBE_API,
+          })
+          .then(() => {
+            LoggerProxy.log('RTD websocket connected successfully', {
+              module: CC_FILE,
+              method: METHODS.CONNECT_WEBSOCKET,
+            });
+            this.services.rtdWebSocketManager.on('message', this.handleRTDWebsocketMessage);
+          })
+          .catch((error) => {
+            LoggerProxy.error(`Error during RTD websocket setup: ${error}`, {
+              module: CC_FILE,
+              method: METHODS.CONNECT_WEBSOCKET,
+            });
+          });
+      }
 
       if (
         this.agentConfig.webRtcEnabled &&
@@ -785,7 +855,11 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         METRIC_EVENT_NAMES.STATION_LOGIN_FAILED,
       ]);
 
-      if (data.loginOption === LoginOption.AGENT_DN && !isValidDialNumber(data.dialNumber)) {
+      const dialPlanEntries = this.agentConfig?.dialPlan?.dialPlanEntity ?? [];
+      if (
+        data.loginOption === LoginOption.AGENT_DN &&
+        !isValidDialNumber(data.dialNumber, dialPlanEntries)
+      ) {
         const error = new Error('INVALID_DIAL_NUMBER');
         // @ts-ignore - adding custom key to the error object
         error.details = {data: {reason: 'INVALID_DIAL_NUMBER'}} as Failure;
@@ -1509,6 +1583,79 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     }
   }
 
+  /**
+   * Accepts a campaign preview contact, initiating the outbound call.
+   *
+   * When a campaign manager reserves a contact for an agent, the agent receives an
+   * `AgentOfferCampaignReservation` event. The agent can then accept the preview contact
+   * to initiate the outbound call.
+   *
+   * @param {PreviewContactPayload} payload - The preview contact payload containing interactionId and campaignId (campaign name, not UUID).
+   * @returns {Promise<TaskResponse>} Promise resolving with agent contact on success.
+   * @throws {Error} If the operation fails (network error, customer unavailable, etc.)
+   *
+   * @example
+   * ```typescript
+   * webex.cc.on('task:campaignPreviewReservation', async (task) => {
+   *   const { interactionId } = task.data;
+   *   // campaignId is the campaign name (e.g. "MyCampaign"), not a UUID
+   *   const campaignId = task.data.interaction.callProcessingDetails.campaignId;
+   *
+   *   const result = await webex.cc.acceptPreviewContact({ interactionId, campaignId });
+   * });
+   * ```
+   */
+  public async acceptPreviewContact(payload: PreviewContactPayload): Promise<TaskResponse> {
+    LoggerProxy.info('Accepting campaign preview contact', {
+      module: CC_FILE,
+      method: METHODS.ACCEPT_PREVIEW_CONTACT,
+    });
+    try {
+      this.metricsManager.timeEvent([
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS,
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+      ]);
+
+      const result = await this.services.dialer.acceptPreviewContact({data: payload});
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponse(result),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+
+      LoggerProxy.log('Campaign preview contact accepted successfully', {
+        module: CC_FILE,
+        method: METHODS.ACCEPT_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId,
+      });
+
+      return result;
+    } catch (error) {
+      const failure = error.details as Failure;
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failure),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.ACCEPT_PREVIEW_CONTACT,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+  }
+
   /**
    * Fetches outdial ANI (Automatic Number Identification) entries for an outdial ANI ID.
    *
@@ -1656,6 +1803,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   /**
    * Updates the agent device type and login configuration.
    * Use this method to change how an agent connects to the contact center system (e.g., switching from browser-based calling to a desk phone extension).
+   * Change to any field of the profile is allowed;
    *
    * @param {AgentDeviceUpdate} data Configuration containing:
    *   - loginOption: New device type ('BROWSER', 'EXTENSION', 'AGENT_DN')
@@ -1695,29 +1843,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     });
 
     try {
-      // Only block if both loginOption AND teamId remain unchanged
-      if (
-        this.webCallingService?.loginOption === data.loginOption &&
-        data.teamId === this.agentConfig.currentTeamId
-      ) {
-        const message =
-          'Will not proceed with device update as new Device type is same as current device type and teamId is same as current teamId';
-        const err = new Error(message) as GenericError;
-        err.details = {
-          type: 'Identical Device Change Failure',
-          orgId: this.$webex.credentials.getOrgId(),
-          trackingId,
-          data: {
-            agentId: this.agentConfig.agentId,
-            reasonCode: 'R002',
-            reason: message,
-          },
-        };
-        throw err;
-      }
-
       await this.stationLogout({
-        logoutReason: 'User requested agent device change',
+        logoutReason: 'User requested agent profile update',
       });
 
       const loginPayload: AgentLogin = {

package/src/constants.ts

@@ -49,4 +49,8 @@ export const METHODS = {
   HANDLE_INCOMING_TASK: 'handleIncomingTask',
   HANDLE_TASK_HYDRATE: 'handleTaskHydrate',
   INCOMING_TASK_LISTENER: 'incomingTaskListener',
+  ACCEPT_PREVIEW_CONTACT: 'acceptPreviewContact',
+  GET_BASE_URL: 'getBaseUrl',
+  SEND_EVENT: 'sendEvent',
+  FETCH_HISTORIC_TRANSCRIPTS: 'fetchHistoricTranscripts',
 };

package/src/index.ts

@@ -28,6 +28,7 @@ export {default as routingAgent} from './services/agent';
 
 // API exports (AddressBook is public, EntryPoint and Queue are accessed via cc wrappers)
 export {default as AddressBook} from './services/AddressBook';
+export {default as ApiAIAssistant} from './services/ApiAiAssistant';
 
 /** EntryPoint API types */
 export type {

package/src/metrics/behavioral-events.ts

@@ -435,6 +435,20 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'outdial_ani_ep_fetch',
     verb: 'fail',
   },
+
+  // Campaign Preview API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_accept',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_accept',
+    verb: 'fail',
+  },
 };
 
 /**

package/src/metrics/constants.ts

@@ -159,6 +159,17 @@ export const METRIC_EVENT_NAMES = {
   // Outdial ANI Entries API Events
   OUTDIAL_ANI_EP_FETCH_SUCCESS: 'Outdial ANI Entries Fetch Success',
   OUTDIAL_ANI_EP_FETCH_FAILED: 'Outdial ANI Entries Fetch Failed',
+
+  // Campaign Preview API Events
+  CAMPAIGN_PREVIEW_ACCEPT_SUCCESS: 'Campaign Preview Accept Success',
+  CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'Campaign Preview Accept Failed',
+
+  // AI Assistant transcript events
+  AI_ASSISTANT_SEND_EVENT_SUCCESS: 'AI Assistant Send Event Success',
+  AI_ASSISTANT_SEND_EVENT_FAILED: 'AI Assistant Send Event Failed',
+  AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_SUCCESS:
+    'AI Assistant Fetch Historic Transcripts Success',
+  AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_FAILED: 'AI Assistant Fetch Historic Transcripts Failed',
 } as const;
 
 /**

package/src/services/ApiAiAssistant.ts

@@ -0,0 +1,217 @@
+import LoggerProxy from '../logger-proxy';
+import MetricsManager from '../metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../metrics/constants';
+import {CC_FILE, METHODS} from '../constants';
+import {
+  HTTP_METHODS,
+  WebexSDK,
+  IHttpResponse,
+  TranscriptAction,
+  AIAssistantEventType,
+  AIAssistantEventName,
+  HistoricTranscriptsResponse,
+} from '../types';
+import {getErrorDetails} from './core/Utils';
+import {
+  AI_ASSISTANT_BASE_URL_TEMPLATE,
+  AI_ASSISTANT_ENV_MAP,
+  AI_ASSISTANT_API_URLS,
+  WCC_API_GATEWAY,
+} from './constants';
+import {AIFeatureFlags} from './config/types';
+
+/**
+ * ApiAIAssistant provides AI Assistant APIs for transcript controls.
+ * @public
+ */
+export class ApiAIAssistant {
+  private webex: WebexSDK;
+  private metricsManager: MetricsManager;
+  public aiFeature: AIFeatureFlags;
+
+  constructor(webex: WebexSDK) {
+    this.webex = webex;
+    this.metricsManager = MetricsManager.getInstance({webex});
+  }
+
+  public setAIFeatureFlags(aiFeature: AIFeatureFlags): void {
+    this.aiFeature = aiFeature;
+  }
+
+  private getBaseUrl(): string {
+    const wccApiGatewayUrl = this.webex.internal.services.get(WCC_API_GATEWAY) || '';
+
+    if (!wccApiGatewayUrl) {
+      const {error: detailedError} = getErrorDetails(
+        new Error('AI_ASSISTANT_BASE_URL_NOT_AVAILABLE'),
+        METHODS.GET_BASE_URL,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+
+    let hostname = '';
+    try {
+      hostname = new URL(wccApiGatewayUrl).hostname.toLowerCase();
+    } catch (error) {
+      hostname = wccApiGatewayUrl.toLowerCase();
+    }
+
+    const resolvedEnv = AI_ASSISTANT_ENV_MAP[hostname];
+    if (!resolvedEnv) {
+      const {error: detailedError} = getErrorDetails(
+        new Error('AI_ASSISTANT_BASE_URL_NOT_AVAILABLE'),
+        METHODS.GET_BASE_URL,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+
+    return AI_ASSISTANT_BASE_URL_TEMPLATE.replace('%s', resolvedEnv);
+  }
+
+  /**
+   * Sends an event to the AI Assistant service.
+   * @param agentId - agent identifier
+   * @param interactionId - interaction/conversation identifier
+   * @param eventType - the type of event (e.g. 'CUSTOM_EVENT')
+   * @param eventName - the name of the event (e.g. 'GET_TRANSCRIPTS')
+   * @param action - action within eventDetails (e.g. 'START' or 'STOP')
+   */
+  public async sendEvent(
+    agentId: string,
+    interactionId: string,
+    eventType: AIAssistantEventType,
+    eventName: AIAssistantEventName,
+    action: TranscriptAction
+  ): Promise<Record<string, unknown>> {
+    LoggerProxy.info('Sending event', {
+      module: CC_FILE,
+      method: METHODS.SEND_EVENT,
+      interactionId,
+      data: {eventType, eventName, action},
+    });
+    this.metricsManager.timeEvent([
+      METRIC_EVENT_NAMES.AI_ASSISTANT_SEND_EVENT_SUCCESS,
+      METRIC_EVENT_NAMES.AI_ASSISTANT_SEND_EVENT_FAILED,
+    ]);
+
+    try {
+      const baseUrl = this.getBaseUrl();
+      const orgId = this.webex.credentials.getOrgId();
+      const response = (await this.webex.request({
+        uri: `${baseUrl}${AI_ASSISTANT_API_URLS.EVENT}`,
+        method: HTTP_METHODS.POST,
+        addAuthHeader: true,
+        body: {
+          agentId,
+          orgId,
+          eventType,
+          eventName,
+          eventDetails: {
+            data: {
+              interactionId,
+              action,
+              actionTimeStamp: String(Date.now()),
+            },
+          },
+        },
+      })) as IHttpResponse;
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_SEND_EVENT_SUCCESS,
+        {agentId, orgId, interactionId, eventType, eventName, action},
+        ['operational']
+      );
+
+      return response?.body || {};
+    } catch (error) {
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_SEND_EVENT_FAILED,
+        {
+          interactionId,
+          eventType,
+          eventName,
+          action,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        ['operational']
+      );
+
+      const {error: detailedError} = getErrorDetails(error, METHODS.SEND_EVENT, CC_FILE);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Fetches historic transcripts for an interaction.
+   * This API is allowed only when real-time transcription feature is enabled.
+   *
+   * @param interactionId - interaction/conversation identifier
+   */
+  public async fetchHistoricTranscripts(
+    agentId: string,
+    interactionId: string
+  ): Promise<HistoricTranscriptsResponse> {
+    LoggerProxy.info('Fetching historic transcripts', {
+      module: CC_FILE,
+      method: METHODS.FETCH_HISTORIC_TRANSCRIPTS,
+      interactionId,
+    });
+    this.metricsManager.timeEvent([
+      METRIC_EVENT_NAMES.AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_SUCCESS,
+      METRIC_EVENT_NAMES.AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_FAILED,
+    ]);
+    if (!this.aiFeature?.realtimeTranscripts?.enable) {
+      const {error: detailedError} = getErrorDetails(
+        new Error('REAL_TIME_TRANSCRIPTION_NOT_ENABLED'),
+        METHODS.FETCH_HISTORIC_TRANSCRIPTS,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+
+    try {
+      const baseUrl = this.getBaseUrl();
+      const orgId = this.webex.credentials.getOrgId();
+      const response = (await this.webex.request({
+        uri: `${baseUrl}${AI_ASSISTANT_API_URLS.TRANSCRIPTS_LIST}`,
+        method: HTTP_METHODS.POST,
+        addAuthHeader: true,
+        body: {
+          agentId,
+          orgId,
+          interactionId,
+        },
+      })) as IHttpResponse;
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_SUCCESS,
+        {agentId, orgId, interactionId},
+        ['operational']
+      );
+
+      return response.body as HistoricTranscriptsResponse;
+    } catch (error) {
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_FETCH_HISTORIC_TRANSCRIPTS_FAILED,
+        {
+          interactionId,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        ['operational']
+      );
+      if (error instanceof Error) {
+        throw error;
+      }
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.FETCH_HISTORIC_TRANSCRIPTS,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+  }
+}
+
+export default ApiAIAssistant;

package/src/services/agent/types.ts

@@ -259,7 +259,7 @@ export type Logout = {
   logoutReason?:
     | 'User requested logout'
     | 'Inactivity Logout'
-    | 'User requested agent device change';
+    | 'User requested agent profile update';
 };
 
 /**

package/src/services/config/Util.ts

@@ -14,6 +14,8 @@ import {
   TenantData,
   URLMapping,
   WRAP_UP_CODE,
+  AIFeatureFlagsResponse,
+  AIFeatureFlags,
 } from './types';
 
 /**
@@ -140,6 +142,7 @@ function parseAgentConfigs(profileData: {
   dialPlanData: DialPlanEntity[];
   urlMapping: URLMapping[];
   multimediaProfileId: string;
+  aiFeatureFlags: AIFeatureFlagsResponse;
 }): Profile {
   const {
     userData,
@@ -151,6 +154,7 @@ function parseAgentConfigs(profileData: {
     agentProfileData,
     dialPlanData,
     urlMapping,
+    aiFeatureFlags,
   } = profileData;
 
   const tenantDataTimeout = tenantData.timeoutDesktopInactivityEnabled
@@ -180,6 +184,8 @@ function parseAgentConfigs(profileData: {
   }); // pushing available state to idle codes
 
   const defaultWrapUpData = getDefaultWrapUpCode(wrapupCodes);
+  const aiFeature: AIFeatureFlags | undefined =
+    aiFeatureFlags?.data && aiFeatureFlags.data.length > 0 ? aiFeatureFlags.data[0] : undefined;
 
   const finalData = {
     teams: teamData,
@@ -204,6 +210,7 @@ function parseAgentConfigs(profileData: {
     siteId: userData.siteId,
     enterpriseId: orgInfoData.tenantId,
     tenantTimezone: orgInfoData.timezone,
+    environment: orgInfoData.environment,
     privacyShieldVisible: tenantData.privacyShieldVisible,
     organizationIdleCodes: [], // TODO: for supervisor, getOrgFilteredIdleCodes(auxCodes, false),
     idleCodesAccess: agentProfileData.accessIdleCode as 'ALL' | 'SPECIFIC',
@@ -253,6 +260,7 @@ function parseAgentConfigs(profileData: {
     webexConfig: getWebexConfig(agentProfileData),
     lostConnectionRecoveryTimeout:
       tenantData.lostConnectionRecoveryTimeout || LOST_CONNECTION_RECOVERY_TIMEOUT,
+    aiFeature,
   };
 
   return finalData;

package/src/services/config/constants.ts

@@ -67,6 +67,8 @@ export const METHODS = {
   GET_TENANT_DATA: 'getTenantData',
   GET_URL_MAPPING: 'getURLMapping',
   GET_DIAL_PLAN_DATA: 'getDialPlanData',
+  GET_AI_FEATURE_FLAGS: 'getAIFeatureFlags',
+  GET_QUEUES: 'getQueues',
 
   // Util methods
   PARSE_AGENT_CONFIGS: 'parseAgentConfigs',
@@ -232,6 +234,16 @@ export const endPointMap = {
    * @ignore
    */
   dialPlan: (orgId: string) => `organization/${orgId}/dial-plan?agentView=true`,
+  /**
+   * Gets the endpoint for listing AI feature flags.
+   * @param orgId - Organization ID.
+   * @returns The endpoint URL string.
+   * @public
+   * @example
+   * const url = endPointMap.aiFeatureFlags('org123');
+   * @ignore
+   */
+  aiFeature: (orgId: string) => `organization/${orgId}/v2/ai-feature?page=0&pageSize=100`,
 
   /**
    * Gets the endpoint for the queue list with custom query parameters.