@webex/contact-center 3.12.0-next.16 → 3.12.0-next.161

package/src/metrics/behavioral-events.ts

@@ -313,6 +313,104 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'task_outdial',
     verb: 'fail',
   },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_MUTE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_mute_webex_together',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_MUTE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_mute_webex_together',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_dtmf_webex_together',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_dtmf_webex_together',
+    verb: 'fail',
+  },
+
+  // Webex Together (wxApp)
+  [METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_accept_webex_together',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_accept_webex_together',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_reject_webex_together',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_reject_webex_together',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_session_init',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_session_init',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_session_init',
+    verb: 'ignore',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_usersub_publish',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_usersub_publish',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_mercury_subscribe',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_mercury_subscribe',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING]: {
+    product,
+    agent: 'user',
+    target: 'webex_together_offer_participant_fields',
+    verb: 'fail',
+  },
 
   // Conference Tasks
   [METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS]: {
@@ -352,6 +450,48 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     verb: 'fail',
   },
 
+  // Conference Exit
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_exit',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_exit',
+    verb: 'fail',
+  },
+
+  // Conference Participant Drop
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_participant_drop',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_conference_participant_drop',
+    verb: 'fail',
+  },
+
+  // Switch Call
+  [METRIC_EVENT_NAMES.TASK_SWITCH_CALL_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'task_switch_call',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.TASK_SWITCH_CALL_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'task_switch_call',
+    verb: 'fail',
+  },
+
   // upload logs
   [METRIC_EVENT_NAMES.UPLOAD_LOGS_SUCCESS]: {
     product,
@@ -477,6 +617,56 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'campaign_preview_remove',
     verb: 'fail',
   },
+
+  // User Preference API Events
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_GET_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_get',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_GET_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_get',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_create',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_create',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_update',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_update',
+    verb: 'fail',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_delete',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'user_preference_delete',
+    verb: 'fail',
+  },
 };
 
 /**

package/src/metrics/constants.ts

@@ -129,20 +129,44 @@ export const METRIC_EVENT_NAMES = {
   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_CONFERENCE_EXIT_SUCCESS: 'Task Conference Exit Success',
+  TASK_CONFERENCE_EXIT_FAILED: 'Task Conference Exit Failed',
+  TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS: 'Task Conference Participant Drop Success',
+  TASK_CONFERENCE_PARTICIPANT_DROP_FAILED: 'Task Conference Participant Drop Failed',
+  TASK_SWITCH_CALL_SUCCESS: 'Task Switch Call Success',
+  TASK_SWITCH_CALL_FAILED: 'Task Switch Call Failed',
 
   TASK_OUTDIAL_SUCCESS: 'Task Outdial Success',
   TASK_OUTDIAL_FAILED: 'Task Outdial Failed',
 
+  WXAPP_TASK_MUTE_SUCCESS: 'WxApp Task Mute Success',
+  WXAPP_TASK_MUTE_FAILED: 'WxApp Task Mute Failed',
+  WXAPP_TASK_DTMF_SUCCESS: 'WxApp Task Dtmf Success',
+  WXAPP_TASK_DTMF_FAILED: 'WxApp Task Dtmf Failed',
+
+  // WxApp Better Together
+  WXAPP_TASK_ACCEPT_SUCCESS: 'WxApp Task Accept Success',
+  WXAPP_TASK_ACCEPT_FAILED: 'WxApp Task Accept Failed',
+  WXAPP_TASK_DECLINE_SUCCESS: 'WxApp Task Decline Success',
+  WXAPP_TASK_DECLINE_FAILED: 'WxApp Task Decline Failed',
+  WXAPP_SESSION_INIT_SUCCESS: 'WxApp Session Init Success',
+  WXAPP_SESSION_INIT_FAILED: 'WxApp Session Init Failed',
+  WXAPP_SESSION_SKIPPED: 'WxApp Session Skipped',
+  WXAPP_USERSUB_PUBLISH_SUCCESS: 'WxApp Usersub Publish Success',
+  WXAPP_USERSUB_PUBLISH_FAILED: 'WxApp Usersub Publish Failed',
+  WXAPP_MERCURY_SUBSCRIBE_SUCCESS: 'WxApp Mercury Subscribe Success',
+  WXAPP_MERCURY_SUBSCRIBE_FAILED: 'WxApp Mercury Subscribe Failed',
+  WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING: 'WxApp Offer Participant Fields Missing',
+
   UPLOAD_LOGS_SUCCESS: 'Upload Logs Success',
   UPLOAD_LOGS_FAILED: 'Upload Logs Failed',
   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',
+  // WebSocket message events
+  WEBSOCKET_EVENT_RECEIVED: 'Websocket Event Received',
 
   // EntryPoint API Events
   ENTRYPOINT_FETCH_SUCCESS: 'Entrypoint Fetch Success',
@@ -168,12 +192,43 @@ export const METRIC_EVENT_NAMES = {
   CAMPAIGN_PREVIEW_REMOVE_SUCCESS: 'Campaign Preview Remove Success',
   CAMPAIGN_PREVIEW_REMOVE_FAILED: 'Campaign Preview Remove Failed',
 
-  // AI Assistant transcript events
+  // 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_GET_REAL_TIME_ASSISTANCE_SUCCESS: 'AI Assistant Get Real Time Assistance Success',
+  AI_ASSISTANT_GET_REAL_TIME_ASSISTANCE_FAILED: 'AI Assistant Get Real Time Assistance Failed',
+  AI_ASSISTANT_SEND_REAL_TIME_ASSISTANCE_USER_ACTION_SUCCESS:
+    'AI Assistant Send Real Time Assistance User Action Success',
+  AI_ASSISTANT_SEND_REAL_TIME_ASSISTANCE_USER_ACTION_FAILED:
+    'AI Assistant Send Real Time Assistance User Action 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',
+  AI_ASSISTANT_WELLNESS_ACTION_ACCEPTED: 'AI Assistant Wellness Action Accepted',
+  AI_ASSISTANT_WELLNESS_ACTION_FAILED: 'AI Assistant Wellness Action Failed',
+  AI_ASSISTANT_WELLNESS_EVENT_INVALID: 'AI Assistant Wellness Event Invalid',
+  WELLBEING_BREAK_IDLE_CODE_FETCH_SUCCESS: 'Wellbeing Break Idle Code Fetch Success',
+  WELLBEING_BREAK_IDLE_CODE_FETCH_FAILED: 'Wellbeing Break Idle Code Fetch Failed',
+
+  // AI summary events
+  AI_SUMMARY_GET_POST_CALL_SUCCESS: 'Post Call Summary Get Success',
+  AI_SUMMARY_GET_POST_CALL_FAILED: 'Post Call Summary Get Failed',
+  AI_SUMMARY_GET_MID_CALL_SUCCESS: 'Mid Call Summary Get Success',
+  AI_SUMMARY_GET_MID_CALL_FAILED: 'Mid Call Summary Get Failed',
+  AI_SUMMARY_POST_CALL_RESPONSE_SUCCESS: 'Post Call Summary Response Success',
+  AI_SUMMARY_POST_CALL_RESPONSE_FAILED: 'Post Call Summary Response Failed',
+  AI_SUMMARY_MID_CALL_RESPONSE_SUCCESS: 'Mid Call Summary Response Success',
+  AI_SUMMARY_MID_CALL_RESPONSE_FAILED: 'Mid Call Summary Response Failed',
+
+  // User Preference API Events
+  USER_PREFERENCE_GET_SUCCESS: 'User Preference Get Success',
+  USER_PREFERENCE_GET_FAILED: 'User Preference Get Failed',
+  USER_PREFERENCE_CREATE_SUCCESS: 'User Preference Create Success',
+  USER_PREFERENCE_CREATE_FAILED: 'User Preference Create Failed',
+  USER_PREFERENCE_UPDATE_SUCCESS: 'User Preference Update Success',
+  USER_PREFERENCE_UPDATE_FAILED: 'User Preference Update Failed',
+  USER_PREFERENCE_DELETE_SUCCESS: 'User Preference Delete Success',
+  USER_PREFERENCE_DELETE_FAILED: 'User Preference Delete Failed',
 } as const;
 
 /**

package/src/services/AddressBook.ts

@@ -74,7 +74,8 @@ export class AddressBook {
 
   /**
    * Fetches address book entries for a specific address book using the entry API
-   * @param {AddressBookEntrySearchParams} [params] - Search and pagination parameters including addressBookId
+   * @param {AddressBookEntrySearchParams} [params] - Search, pagination, and optional sort parameters
+   * including addressBookId. Sorting defaults to name ascending.
    * @returns {Promise<AddressBookEntriesResponse>} Promise resolving to address book entries
    * @throws {Error} If the API call fails
    * @public
@@ -102,12 +103,21 @@ export class AddressBook {
       search,
       filter,
       attributes,
+      sortBy = 'name',
+      sortOrder = 'asc',
     } = 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);
+    const hasCustomSort = sortBy !== 'name' || sortOrder !== 'asc';
+    const isSearchRequest = !!(search || filter || attributes || hasCustomSort);
+    const canUseCache = this.pageCache.canUseCache({
+      search,
+      filter,
+      attributes,
+      sortBy: hasCustomSort ? sortBy : undefined,
+    });
 
     LoggerProxy.info('Fetching address book entries', {
       module: 'AddressBook',
@@ -121,8 +131,8 @@ export class AddressBook {
       },
     });
 
-    // Check if we can use cache for simple pagination (no search/filter/attributes)
-    if (this.pageCache.canUseCache({search, filter, attributes})) {
+    // Default name-ascending pagination is cache-compatible; result-changing overrides are not.
+    if (canUseCache) {
       const cacheKey = this.pageCache.buildCacheKey(bookId, page, pageSize);
       const cachedPage = this.pageCache.getCachedPage(cacheKey);
 
@@ -190,6 +200,7 @@ export class AddressBook {
       if (filter) queryParams.append('filter', filter);
       if (attributes) queryParams.append('attributes', attributes);
       if (search) queryParams.append('search', search);
+      if (sortBy) queryParams.append('sort', `${sortBy},${sortOrder.toUpperCase()}`);
 
       const resource = endPointMap.addressBookEntries(orgId, bookId, queryParams.toString());
 
@@ -244,8 +255,8 @@ export class AddressBook {
         );
       }
 
-      // Cache the page data for simple pagination (no search/filter/attributes)
-      if (this.pageCache.canUseCache({search, filter, attributes}) && response.body?.data) {
+      // Cache only the invariant default-order pagination shape.
+      if (canUseCache && response.body?.data) {
         const cacheKey = this.pageCache.buildCacheKey(bookId, page, pageSize);
         this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);
 

package/src/services/AnswerCallOnWebexService.ts

@@ -0,0 +1,239 @@
+import LoggerProxy from '../logger-proxy';
+import {CC_FILE, METHODS} from '../constants';
+import {HTTP_METHODS, IHttpResponse, WebexSDK} from '../types';
+import {getErrorDetails} from './core/Utils';
+import {isWxAppCallNotFoundError} from './wxAppTelephonyUtils';
+
+const ANSWER_CALL_ON_WEBEX_FILE = 'AnswerCallOnWebexService';
+
+export type WxAppTelephonyError = Error & {
+  isWxAppTelephonyError: true;
+  trackingId?: string;
+  status?: number | string;
+};
+
+const extractWxAppTrackingId = (source: unknown): string | undefined => {
+  const sourceObj = source as {details?: {trackingId?: string}; trackingId?: string};
+
+  return sourceObj?.details?.trackingId || sourceObj?.trackingId;
+};
+
+const extractWxAppHttpStatus = (source: unknown): number | string | undefined => {
+  const obj = source as {
+    statusCode?: number;
+    status?: number | string;
+    details?: {status?: number | string};
+  };
+
+  return obj?.statusCode ?? obj?.status ?? obj?.details?.status;
+};
+
+const markWxAppTelephonyError = (error: Error, source: unknown): WxAppTelephonyError => {
+  const marked = error as WxAppTelephonyError;
+  marked.isWxAppTelephonyError = true;
+  const trackingId = extractWxAppTrackingId(source);
+  if (trackingId) {
+    marked.trackingId = trackingId;
+  }
+  const status = extractWxAppHttpStatus(source);
+  if (status !== undefined) {
+    marked.status = status;
+  }
+
+  return marked;
+};
+
+export type AnswerCallParams = {
+  callId: string;
+  endpointId: string;
+  lineOwnerId?: string;
+};
+
+export type CallIdParams = {
+  callId: string;
+  lineOwnerId?: string;
+};
+
+export type TransmitDtmfParams = CallIdParams & {
+  dtmf: string;
+};
+
+export type CallDetailsResponse = {
+  muted?: boolean;
+};
+
+/**
+ * REST telephony client for wxApp thick-client answer (WXCC-6026).
+ * Separate from WebCallingService (WebRTC/Mobius).
+ */
+export default class AnswerCallOnWebexService {
+  private webex: WebexSDK;
+
+  constructor(webex: WebexSDK) {
+    this.webex = webex;
+  }
+
+  private getTelephonyBaseUrl(): string {
+    const services = this.webex.internal.services;
+    const hydraUrl = services._serviceUrls?.hydra || services.get('hydra');
+
+    if (!hydraUrl) {
+      throw new Error('Telephony base URL is unavailable');
+    }
+
+    return `${hydraUrl.replace(/\/$/, '')}/telephony/calls`;
+  }
+
+  private extractTrackingId(source: unknown): string | undefined {
+    return extractWxAppTrackingId(source);
+  }
+
+  private async telephonyRequest(
+    resource: string,
+    method: HTTP_METHODS,
+    body: Record<string, unknown>,
+    logMethod: string
+  ): Promise<IHttpResponse> {
+    try {
+      const uri = `${this.getTelephonyBaseUrl()}${resource}`;
+
+      LoggerProxy.log(`AnswerCallOnWebexService.${logMethod} request`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {uri, bodyKeys: Object.keys(body)},
+      });
+
+      const response = (await this.webex.request({
+        uri,
+        method,
+        body,
+        addAuthHeader: true,
+      })) as IHttpResponse;
+
+      LoggerProxy.log(`AnswerCallOnWebexService.${logMethod} success`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {statusCode: response.statusCode},
+      });
+
+      return response;
+    } catch (error) {
+      const trackingId = this.extractTrackingId(error);
+      LoggerProxy.error(`AnswerCallOnWebexService.${logMethod} failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {
+          trackingId,
+          status: extractWxAppHttpStatus(error),
+        },
+      });
+      const {error: detailedError} = getErrorDetails(error, logMethod, CC_FILE);
+      throw markWxAppTelephonyError(detailedError, error);
+    }
+  }
+
+  public answerCall(params: AnswerCallParams): Promise<IHttpResponse> {
+    const {callId, endpointId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/answer',
+      HTTP_METHODS.POST,
+      {
+        callId,
+        endpointId,
+        ...(lineOwnerId ? {lineOwnerId} : {}),
+      },
+      METHODS.ACCEPT
+    );
+  }
+
+  public rejectCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/reject',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.REJECT
+    );
+  }
+
+  public muteCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/mute',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TOGGLE_MUTE
+    );
+  }
+
+  public unmuteCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/unmute',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TOGGLE_MUTE
+    );
+  }
+
+  public transmitDtmf(params: TransmitDtmfParams): Promise<IHttpResponse> {
+    const {callId, dtmf, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/transmitDtmf',
+      HTTP_METHODS.POST,
+      {callId, dtmf, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TRANSMIT_DTMF
+    );
+  }
+
+  public async getCallDetails(params: CallIdParams): Promise<CallDetailsResponse> {
+    const {callId, lineOwnerId} = params;
+    const lineOwnerIdQuery = lineOwnerId ? `?lineOwnerId=${encodeURIComponent(lineOwnerId)}` : '';
+    const uri = `${this.getTelephonyBaseUrl()}/${callId}${lineOwnerIdQuery}`;
+
+    try {
+      LoggerProxy.log('AnswerCallOnWebexService.getCallDetails request', {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        data: {callIdSuffix: callId.length <= 8 ? callId : callId.slice(-8)},
+      });
+
+      const response = (await this.webex.request({
+        uri,
+        method: HTTP_METHODS.GET,
+        addAuthHeader: true,
+      })) as IHttpResponse;
+
+      return (response.body ?? {}) as CallDetailsResponse;
+    } catch (error) {
+      if (isWxAppCallNotFoundError(error)) {
+        const err =
+          error instanceof Error
+            ? error
+            : new Error(String((error as {message?: string})?.message ?? error));
+        throw markWxAppTelephonyError(err, error);
+      }
+
+      const trackingId = this.extractTrackingId(error);
+      LoggerProxy.error(`AnswerCallOnWebexService.getCallDetails failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        data: {
+          trackingId,
+          status: extractWxAppHttpStatus(error),
+        },
+      });
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        CC_FILE
+      );
+      throw markWxAppTelephonyError(detailedError, error);
+    }
+  }
+}