@webex/contact-center 3.8.1 → 3.9.0-multi-llms.2

package/src/metrics/behavioral-events.ts

@@ -129,6 +129,18 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'agent_rona',
     verb: 'set',
   },
+  [METRIC_EVENT_NAMES.AGENT_CONTACT_ASSIGN_FAILED]: {
+    product,
+    agent: 'service',
+    target: 'agent_contact_assign',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.AGENT_INVITE_FAILED]: {
+    product,
+    agent: 'service',
+    target: 'agent_invite',
+    verb: 'fail',
+  },
 
   // Added Task events
   [METRIC_EVENT_NAMES.TASK_ACCEPT_SUCCESS]: {
@@ -290,6 +302,44 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     verb: 'fail',
   },
 
+  // Conference Tasks
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_start',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_start',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_END_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_end',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_END_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_end',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_transfer',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_transfer',
+    verb: 'fail',
+  },
+
   // upload logs
   [METRIC_EVENT_NAMES.UPLOAD_LOGS_SUCCESS]: {
     product,
@@ -317,6 +367,48 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'agent_device_type_update',
     verb: 'fail',
   },
+
+  // EntryPoint API Events
+  [METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'entrypoint_fetch',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'entrypoint_fetch',
+    verb: 'fail',
+  },
+
+  // AddressBook API Events
+  [METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'addressbook_fetch',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'addressbook_fetch',
+    verb: 'fail',
+  },
+
+  // Queue API Events
+  [METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'queue_fetch',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.QUEUE_FETCH_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'queue_fetch',
+    verb: 'fail',
+  },
 };
 
 /**

package/src/metrics/constants.ts

@@ -37,7 +37,6 @@ type Enum<T extends Record<string, unknown>> = T[keyof T];
  * @property {string} TASK_HOLD_FAILED - Event name for failed task hold.
  * @property {string} TASK_RESUME_SUCCESS - Event name for successful task resume.
  * @property {string} TASK_RESUME_FAILED - Event name for failed task resume.
- *
  * @property {string} TASK_CONSULT_START_SUCCESS - Event name for successful consult start.
  * @property {string} TASK_CONSULT_START_FAILED - Event name for failed consult start.
  * @property {string} TASK_CONSULT_END_SUCCESS - Event name for successful consult end.
@@ -51,6 +50,13 @@ type Enum<T extends Record<string, unknown>> = T[keyof T];
  * @property {string} TASK_ACCEPT_CONSULT_SUCCESS - Event name for successful consult acceptance.
  * @property {string} TASK_ACCEPT_CONSULT_FAILED - Event name for failed consult acceptance.
  *
+ * @property {string} TASK_CONFERENCE_START_SUCCESS - Event name for successful conference start.
+ * @property {string} TASK_CONFERENCE_START_FAILED - Event name for failed conference start.
+ * @property {string} TASK_CONFERENCE_END_SUCCESS - Event name for successful conference end.
+ * @property {string} TASK_CONFERENCE_END_FAILED - Event name for failed conference end.
+ * @property {string} TASK_CONFERENCE_TRANSFER_SUCCESS - Event name for successful conference transfer.
+ * @property {string} TASK_CONFERENCE_TRANSFER_FAILED - Event name for failed conference transfer.
+ *
  * @property {string} TASK_OUTDIAL_SUCCESS - Event name for successful outdial task.
  * @property {string} TASK_OUTDIAL_FAILED - Event name for failed outdial task.
  *
@@ -62,6 +68,9 @@ type Enum<T extends Record<string, unknown>> = T[keyof T];
  * @property {string} AGENT_DEVICE_TYPE_UPDATE_SUCCESS - Event name for successful agent device type update.
  * @property {string} AGENT_DEVICE_TYPE_UPDATE_FAILED - Event name for failed agent device type update.
  *
+ * @property {string} OUTDIAL_ANI_EP_FETCH_SUCCESS - Event name for successful outdial ANI entries fetch.
+ * @property {string} OUTDIAL_ANI_EP_FETCH_FAILED - Event name for failed outdial ANI entries fetch.
+ *
  * @readonly
  */
 export const METRIC_EVENT_NAMES = {
@@ -109,6 +118,14 @@ export const METRIC_EVENT_NAMES = {
   TASK_ACCEPT_CONSULT_SUCCESS: 'Task Accept Consult Success',
   TASK_ACCEPT_CONSULT_FAILED: 'Task Accept Consult Failed',
 
+  // Conference Tasks
+  TASK_CONFERENCE_START_SUCCESS: 'Task Conference Start Success',
+  TASK_CONFERENCE_START_FAILED: 'Task Conference Start Failed',
+  TASK_CONFERENCE_END_SUCCESS: 'Task Conference End Success',
+  TASK_CONFERENCE_END_FAILED: 'Task Conference End Failed',
+  TASK_CONFERENCE_TRANSFER_SUCCESS: 'Task Conference Transfer Success',
+  TASK_CONFERENCE_TRANSFER_FAILED: 'Task Conference Transfer Failed',
+
   TASK_OUTDIAL_SUCCESS: 'Task Outdial Success',
   TASK_OUTDIAL_FAILED: 'Task Outdial Failed',
 
@@ -117,8 +134,27 @@ export const METRIC_EVENT_NAMES = {
   WEBSOCKET_DEREGISTER_SUCCESS: 'Websocket Deregister Success',
   WEBSOCKET_DEREGISTER_FAIL: 'Websocket Deregister Failed',
 
+  // WebSocket message events
+  WEBSOCKET_EVENT_RECEIVED: 'Websocket Event Received',
+
   AGENT_DEVICE_TYPE_UPDATE_SUCCESS: 'Agent Device Type Update Success',
   AGENT_DEVICE_TYPE_UPDATE_FAILED: 'Agent Device Type Update Failed',
+
+  // EntryPoint API Events
+  ENTRYPOINT_FETCH_SUCCESS: 'Entrypoint Fetch Success',
+  ENTRYPOINT_FETCH_FAILED: 'Entrypoint Fetch Failed',
+
+  // AddressBook API Events
+  ADDRESSBOOK_FETCH_SUCCESS: 'AddressBook Fetch Success',
+  ADDRESSBOOK_FETCH_FAILED: 'AddressBook Fetch Failed',
+
+  // Queue API Events
+  QUEUE_FETCH_SUCCESS: 'Queue Fetch Success',
+  QUEUE_FETCH_FAILED: 'Queue Fetch Failed',
+
+  // 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',
 } as const;
 
 /**

package/src/services/AddressBook.ts

@@ -0,0 +1,291 @@
+import {HTTP_METHODS, WebexSDK} from '../types';
+import type {
+  AddressBookEntry,
+  AddressBookEntriesResponse,
+  AddressBookEntrySearchParams,
+} from '../types';
+import LoggerProxy from '../logger-proxy';
+import WebexRequest from './core/WebexRequest';
+import PageCache, {PAGINATION_DEFAULTS} from '../utils/PageCache';
+import MetricsManager from '../metrics/MetricsManager';
+import {WCC_API_GATEWAY} from './constants';
+import {endPointMap} from './config/constants';
+import {METRIC_EVENT_NAMES} from '../metrics/constants';
+
+/**
+ * AddressBook API class for managing Webex Contact Center address book entries.
+ * Provides functionality to fetch address book entries using the entry API.
+ *
+ * @class AddressBook
+ * @public
+ * @example
+ * ```typescript
+ * import Webex from 'webex';
+ *
+ * const webex = new Webex({ credentials: 'YOUR_ACCESS_TOKEN' });
+ * const cc = webex.cc;
+ *
+ * // Register and login first
+ * await cc.register();
+ * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+ *
+ * // Get AddressBook API instance from ContactCenter
+ * const addressBookAPI = cc.addressBook;
+ *
+ * // Get entries from agent's default address book
+ * const entries = await addressBookAPI.getEntries();
+ *
+ * // Get entries from a specific address book with pagination
+ * const entries = await addressBookAPI.getEntries({
+ *   addressBookId: 'addressBookId123',
+ *   page: 0,
+ *   pageSize: 50
+ * });
+ *
+ * // Search for specific entries
+ * const searchResults = await addressBook.getEntries({
+ *   search: 'john',
+ *   filter: 'name=="John Doe"'
+ * });
+ * ```
+ */
+export class AddressBook {
+  private webexRequest: WebexRequest;
+  private webex: WebexSDK;
+  private getAddressBookId: () => string;
+  private metricsManager: MetricsManager;
+
+  // Page cache using the common utility
+  private pageCache: PageCache<AddressBookEntry>;
+
+  /**
+   * Creates an instance of AddressBook
+   * @param {WebexSDK} webex - The Webex SDK instance
+   * @param {() => string} getAddressBookId - Function to get the addressBookId from agent profile
+   * @public
+   */
+  constructor(webex: WebexSDK, getAddressBookId: () => string) {
+    this.webex = webex;
+    this.webexRequest = WebexRequest.getInstance({webex});
+    this.getAddressBookId = getAddressBookId;
+    this.pageCache = new PageCache<AddressBookEntry>('AddressBook');
+    this.metricsManager = MetricsManager.getInstance({webex});
+  }
+
+  /**
+   * Fetches address book entries for a specific address book using the entry API
+   * @param {AddressBookEntrySearchParams} [params] - Search and pagination parameters including addressBookId
+   * @returns {Promise<AddressBookEntriesResponse>} Promise resolving to address book entries
+   * @throws {Error} If the API call fails
+   * @public
+   * @example
+   * ```typescript
+   * // Get entries from agent's default address book
+   * const response = await addressBookAPI.getEntries();
+   *
+   * // Get entries from a specific address book with pagination
+   * const response = await addressBookAPI.getEntries({
+   *   addressBookId: 'addressBookId123',
+   *   page: 0,
+   *   pageSize: 25
+   * });
+   * ```
+   */
+  public async getEntries(
+    params: AddressBookEntrySearchParams = {}
+  ): Promise<AddressBookEntriesResponse> {
+    const startTime = Date.now();
+    const {
+      addressBookId,
+      page = PAGINATION_DEFAULTS.PAGE,
+      pageSize = PAGINATION_DEFAULTS.PAGE_SIZE,
+      search,
+      filter,
+      attributes,
+    } = params;
+
+    // Use provided addressBookId or fall back to agent's address book
+    const bookId = addressBookId || this.getAddressBookId();
+    const orgId = this.webex.credentials.getOrgId();
+    const isSearchRequest = !!(search || filter || attributes);
+
+    LoggerProxy.info('Fetching address book entries', {
+      module: 'AddressBook',
+      method: 'getEntries',
+      data: {
+        orgId,
+        bookId,
+        page,
+        pageSize,
+        isSearchRequest,
+      },
+    });
+
+    // Check if we can use cache for simple pagination (no search/filter/attributes)
+    if (this.pageCache.canUseCache({search, filter, attributes})) {
+      const cacheKey = this.pageCache.buildCacheKey(bookId, page, pageSize);
+      const cachedPage = this.pageCache.getCachedPage(cacheKey);
+
+      if (cachedPage) {
+        const duration = Date.now() - startTime;
+
+        LoggerProxy.info(`Returning page ${page} from cache`, {
+          module: 'AddressBook',
+          method: 'getEntries',
+          data: {
+            cacheHit: true,
+            duration,
+            recordCount: cachedPage.data.length,
+            page,
+            pageSize,
+          },
+        });
+
+        return {
+          data: cachedPage.data,
+          meta: {
+            page,
+            pageSize,
+            totalPages: cachedPage.totalMeta?.totalPages,
+            totalRecords: cachedPage.totalMeta?.totalRecords,
+          },
+        };
+      }
+    }
+
+    // Start timing for the operation
+    this.metricsManager.timeEvent(METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS);
+
+    // Validate address book id early to avoid bad requests
+    if (!bookId) {
+      const errorData = {
+        orgId,
+        bookId,
+        isSearchRequest,
+        page,
+        pageSize,
+        error: 'Missing addressBookId for agent. Ensure agent profile contains addressBookId.',
+      };
+      LoggerProxy.error('AddressBook called without a valid addressBookId', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: errorData,
+      });
+
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw new Error('AddressBook: addressBookId is not available for the current agent.');
+    }
+
+    try {
+      // Build query parameters according to spec
+      const queryParams = new URLSearchParams({
+        page: page.toString(),
+        pageSize: pageSize.toString(),
+      });
+
+      if (filter) queryParams.append('filter', filter);
+      if (attributes) queryParams.append('attributes', attributes);
+      if (search) queryParams.append('search', search);
+
+      const resource = endPointMap.addressBookEntries(orgId, bookId, queryParams.toString());
+
+      LoggerProxy.info('Making API request to fetch address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: {
+          resource,
+          service: WCC_API_GATEWAY,
+        },
+      });
+
+      const response = await this.webexRequest.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.GET,
+      });
+
+      const duration = Date.now() - startTime;
+
+      const recordCount = response.body?.data?.length || 0;
+      const totalRecords = response.body?.meta?.totalRecords;
+
+      LoggerProxy.info(`Successfully retrieved ${recordCount} address book entries`, {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: {
+          statusCode: response.statusCode,
+          duration,
+          recordCount,
+          totalRecords,
+          isSearchRequest,
+          page,
+          pageSize,
+        },
+      });
+
+      // Only track metrics for search requests or first page loads to reduce metric volume
+      if (isSearchRequest || page === 0) {
+        this.metricsManager.trackEvent(
+          METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS,
+          {
+            orgId,
+            bookId,
+            statusCode: response.statusCode,
+            recordCount,
+            totalRecords,
+            isSearchRequest,
+            isFirstPage: page === 0,
+          },
+          ['behavioral', 'operational']
+        );
+      }
+
+      // Cache the page data for simple pagination (no search/filter/attributes)
+      if (this.pageCache.canUseCache({search, filter, attributes}) && response.body?.data) {
+        const cacheKey = this.pageCache.buildCacheKey(bookId, page, pageSize);
+        this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);
+
+        LoggerProxy.info('Cached address book entries for future requests', {
+          module: 'AddressBook',
+          method: 'getEntries',
+          data: {
+            cacheKey,
+            recordCount,
+          },
+        });
+      }
+
+      return response.body;
+    } catch (error) {
+      const errorData = {
+        orgId,
+        bookId,
+        error: error instanceof Error ? error.message : String(error),
+        isSearchRequest,
+        page,
+        pageSize,
+      };
+
+      LoggerProxy.error('Failed to fetch address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: errorData,
+        error,
+      });
+
+      // Track all failures for troubleshooting
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw error;
+    }
+  }
+}
+
+export default AddressBook;