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

package/src/metrics/ai-docs/metrics-spec.md

@@ -240,6 +240,7 @@ All event names are defined in `METRIC_EVENT_NAMES` (`constants.ts`). Events fol
 | `TASK_CONFERENCE_END_SUCCESS` / `FAILED` | `'Task Conference End ...'` | Conference end result |
 | `TASK_CONFERENCE_TRANSFER_SUCCESS` / `FAILED` | `'Task Conference Transfer ...'` | Conference transfer result |
 | `TASK_CONFERENCE_EXIT_SUCCESS` / `FAILED` | `'Task Conference Exit ...'` | Conference exit result |
+| `TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS` / `FAILED` | `'Task Conference Participant Drop ...'` | Participant Drop result |
 | `TASK_SWITCH_CALL_SUCCESS` / `FAILED` | `'Task Switch Call ...'` | Switch call result |
 | `WEBSOCKET_REGISTER_SUCCESS` / `FAILED` | `'Websocket Register ...'` | WebSocket registration result |
 | `WEBSOCKET_DEREGISTER_SUCCESS` / `FAIL` | `'Websocket Deregister ...'` | WebSocket deregistration result |
@@ -277,6 +278,7 @@ All event names are defined in `constants.ts` as `METRIC_EVENT_NAMES`. Events fo
 | Conference End         | `TASK_CONFERENCE_END_SUCCESS`          | `TASK_CONFERENCE_END_FAILED`           |
 | Conference Transfer    | `TASK_CONFERENCE_TRANSFER_SUCCESS`     | `TASK_CONFERENCE_TRANSFER_FAILED`      |
 | Conference Exit        | `TASK_CONFERENCE_EXIT_SUCCESS`         | `TASK_CONFERENCE_EXIT_FAILED`          |
+| Conference Participant Drop | `TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS` | `TASK_CONFERENCE_PARTICIPANT_DROP_FAILED` |
 | Switch Call            | `TASK_SWITCH_CALL_SUCCESS`             | `TASK_SWITCH_CALL_FAILED`              |
 | Outdial                | `TASK_OUTDIAL_SUCCESS`                 | `TASK_OUTDIAL_FAILED`                  |
 | Upload Logs            | `UPLOAD_LOGS_SUCCESS`                  | `UPLOAD_LOGS_FAILED`                   |
@@ -297,11 +299,11 @@ Special events (no success/failure pair):
 
 - `WEBSOCKET_EVENT_RECEIVED` — **no** behavioral taxonomy (not in `eventTaxonomyMap`)
 
-Of the 80 defined metric names, 71 have behavioral taxonomy and 9 do not. Events **without** an `eventTaxonomyMap` entry are the six `AI_ASSISTANT_*` names plus `WEBSOCKET_DEREGISTER_SUCCESS`, `WEBSOCKET_DEREGISTER_FAIL`, and `WEBSOCKET_EVENT_RECEIVED`.
+Of the 82 defined metric names, 73 have behavioral taxonomy and 9 do not. Events **without** an `eventTaxonomyMap` entry are the six `AI_ASSISTANT_*` names plus `WEBSOCKET_DEREGISTER_SUCCESS`, `WEBSOCKET_DEREGISTER_FAIL`, and `WEBSOCKET_EVENT_RECEIVED`.
 
 ### Complete METRIC_EVENT_NAMES catalog
 
-This table contains all 80 names from `src/metrics/constants.ts`; taxonomy presence is checked against `src/metrics/behavioral-events.ts`: 71 mapped and 9 unmapped.
+This table contains all 82 names from `src/metrics/constants.ts`; taxonomy presence is checked against `src/metrics/behavioral-events.ts`: 73 mapped and 9 unmapped.
 
 | Constant | Emitted name | Behavioral taxonomy? |
 |---|---|---|
@@ -354,6 +356,8 @@ This table contains all 80 names from `src/metrics/constants.ts`; taxonomy prese
 | `TASK_CONFERENCE_TRANSFER_FAILED` | `Task Conference Transfer Failed` | yes |
 | `TASK_CONFERENCE_EXIT_SUCCESS` | `Task Conference Exit Success` | yes |
 | `TASK_CONFERENCE_EXIT_FAILED` | `Task Conference Exit Failed` | yes |
+| `TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS` | `Task Conference Participant Drop Success` | yes |
+| `TASK_CONFERENCE_PARTICIPANT_DROP_FAILED` | `Task Conference Participant Drop Failed` | yes |
 | `TASK_SWITCH_CALL_SUCCESS` | `Task Switch Call Success` | yes |
 | `TASK_SWITCH_CALL_FAILED` | `Task Switch Call Failed` | yes |
 | `TASK_OUTDIAL_SUCCESS` | `Task Outdial Success` | yes |
@@ -463,6 +467,8 @@ Example: `wxcc_sdk.user.station_login.complete`
 
 The mapping is defined in `behavioral-events.ts` via `eventTaxonomyMap` and accessed through `getEventTaxonomy(name)`.
 
+Participant Drop uses target `task_conference_participant_drop` with `complete` for success and `fail` for failure. Its metric payload is limited to task/request correlation and standard AQM tracking fields; participant IDs, numbers, names, URLs, headers, and raw routing payloads are excluded.
+
 ```mermaid
 flowchart LR
     A[timeEvent keys] --> B[runningEvents stores startTime + key Set]
@@ -728,7 +734,7 @@ MetricsManager holds three pending queues, running timing entries, a readiness f
 
 ## Business Rules & Invariants
 - `timeEvent` and every tracking method return immediately while metrics are disabled.
-- Only names present in `eventTaxonomyMap` receive behavioral taxonomy; 71 of 80 names are mapped and the six AI Assistant plus three WebSocket names are intentionally catalogued as unmapped.
+- Only names present in `eventTaxonomyMap` receive behavioral taxonomy; 73 of 82 names are mapped and the six AI Assistant plus three WebSocket names are intentionally catalogued as unmapped.
 - `submittingEvents` prevents overlapping queue-drain executions.
 - Authentication is inherited from the host Webex SDK's metrics client; MetricsManager owns no credentials, tokens, or authorization policy.
 

package/src/metrics/behavioral-events.ts

@@ -366,6 +366,20 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     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,

package/src/metrics/constants.ts

@@ -131,6 +131,8 @@ export const METRIC_EVENT_NAMES = {
   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',
 

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,206 @@
+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 markWxAppTelephonyError = (error: Error, source: unknown): WxAppTelephonyError => {
+  const marked = error as WxAppTelephonyError;
+  marked.isWxAppTelephonyError = true;
+  const sourceObj = source as {
+    details?: {trackingId?: string; status?: number | string};
+    statusCode?: number;
+    status?: number | string;
+  };
+  const trackingId = sourceObj?.details?.trackingId;
+  if (trackingId) {
+    marked.trackingId = trackingId;
+  }
+  const status = sourceObj?.statusCode ?? sourceObj?.details?.status ?? sourceObj?.status;
+  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 async telephonyRequest(
+    resource: string,
+    method: HTTP_METHODS,
+    body: Record<string, unknown>,
+    logMethod: string
+  ): Promise<IHttpResponse> {
+    try {
+      const uri = `${this.getTelephonyBaseUrl()}${resource}`;
+
+      LoggerProxy.info(`AnswerCallOnWebexService.${logMethod} request`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {uri, bodyKeys: Object.keys(body)},
+      });
+
+      return (await this.webex.request({
+        uri,
+        method,
+        body,
+        addAuthHeader: true,
+      })) as IHttpResponse;
+    } catch (error) {
+      LoggerProxy.error(`AnswerCallOnWebexService.${logMethod} failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+      });
+      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.info('AnswerCallOnWebexService.getCallDetails request', {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        data: {callId},
+      });
+
+      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);
+      }
+
+      LoggerProxy.error(`AnswerCallOnWebexService.getCallDetails failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+      });
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        CC_FILE
+      );
+      throw markWxAppTelephonyError(detailedError, error);
+    }
+  }
+}

package/src/services/EntryPoint.ts

@@ -2,12 +2,40 @@ import {HTTP_METHODS, WebexSDK} from '../types';
 import type {EntryPointRecord, EntryPointListResponse, EntryPointSearchParams} from '../types';
 import LoggerProxy from '../logger-proxy';
 import WebexRequest from './core/WebexRequest';
-import PageCache, {PAGINATION_DEFAULTS} from '../utils/PageCache';
+import {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';
 
+const DEFAULT_ENTRY_POINT_ATTRIBUTES = 'id,dialledNumber,entryPointId,entryPointName';
+const DEFAULT_ENTRY_POINT_SORT_FIELD = 'entryPointName';
+
+type DialNumberEntryPointRecord = {
+  id: string;
+  dialledNumber?: string;
+  entryPointId: string;
+  entryPointName: string;
+};
+
+const mergeEntryPointAttributes = (attributes?: string): string => {
+  const mergedAttributes = new Set(DEFAULT_ENTRY_POINT_ATTRIBUTES.split(','));
+
+  attributes
+    ?.split(',')
+    .map((attribute) => attribute.trim())
+    .filter(Boolean)
+    .forEach((attribute) => mergedAttributes.add(attribute));
+
+  return Array.from(mergedAttributes).join(',');
+};
+
+const mapDialNumberEntryPoint = (item: DialNumberEntryPointRecord): EntryPointRecord => ({
+  id: item.entryPointId,
+  name: item.entryPointName,
+  ...(item.dialledNumber ? {number: item.dialledNumber} : {}),
+});
+
 /**
  * EntryPoint class for managing Webex Contact Center entry points.
  * Provides functionality to fetch, search, and paginate through entry points.
@@ -35,7 +63,7 @@ import {METRIC_EVENT_NAMES} from '../metrics/constants';
  * });
  *
  * // Search for specific entry points
- * const searchResults = await entryPointAPI.searchEntryPoints({
+ * const searchResults = await entryPointAPI.getEntryPoints({
  *   search: 'support',
  *   filter: 'type=="voice"'
  * });
@@ -46,9 +74,6 @@ export class EntryPoint {
   private webex: WebexSDK;
   private metricsManager: MetricsManager;
 
-  // Page cache using the common utility
-  private pageCache: PageCache<EntryPointRecord>;
-
   /**
    * Creates an instance of EntryPoint
    * @param {WebexSDK} webex - The Webex SDK instance
@@ -57,19 +82,21 @@ export class EntryPoint {
   constructor(webex: WebexSDK) {
     this.webex = webex;
     this.webexRequest = WebexRequest.getInstance({webex});
-    this.pageCache = new PageCache<EntryPointRecord>('EntryPoint');
     this.metricsManager = MetricsManager.getInstance({webex});
   }
 
   /**
-   * Fetches entry points for the organization with pagination support
-   * @param {EntryPointSearchParams} [params] - Search and pagination parameters
+   * Fetches entry-point dial-number mappings for the organization with pagination support. By
+   * default, returns the agent's desktop-profile-filtered mappings in backend entry-point-name order.
+   * Search, filter, attribute, and sort parameters can customize the request while desktop-profile
+   * scoping and required mapping fields remain SDK-owned.
+   * @param {EntryPointSearchParams} [params] - Search, pagination, and compatible override parameters.
    * @returns {Promise<EntryPointListResponse>} Promise resolving to paginated entry points
    * @throws {Error} If the API call fails
    * @public
    * @example
    * ```typescript
-   * // Get first page of entry points
+   * // Get the first page using the default entry-point policy
    * const response = await entryPointAPI.getEntryPoints();
    *
    * // Get specific page with custom page size
@@ -89,12 +116,14 @@ export class EntryPoint {
       search,
       filter,
       attributes,
-      sortBy,
+      sortBy = 'name',
       sortOrder = 'asc',
     } = params;
 
     const orgId = this.webex.credentials.getOrgId();
-    const isSearchRequest = !!(search || filter || attributes || sortBy);
+    const hasCustomSort = sortBy !== 'name' || sortOrder !== 'asc';
+    const isSearchRequest = !!(search || filter || attributes || hasCustomSort);
+    const effectiveSortBy = sortBy === 'name' ? DEFAULT_ENTRY_POINT_SORT_FIELD : sortBy;
 
     LoggerProxy.info(
       `Fetching entry points - orgId: ${orgId}, page: ${page}, pageSize: ${pageSize}, isSearchRequest: ${isSearchRequest}`,
@@ -104,51 +133,24 @@ export class EntryPoint {
       }
     );
 
-    // Check if we can use cache for simple pagination (no search/filter/attributes/sort)
-    if (this.pageCache.canUseCache({search, filter, attributes, sortBy})) {
-      const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
-      const cachedPage = this.pageCache.getCachedPage(cacheKey);
-
-      if (cachedPage) {
-        const duration = Date.now() - startTime;
-
-        LoggerProxy.log(
-          `Returning page ${page} from cache - cacheHit: true, duration: ${duration}ms, recordCount: ${cachedPage.data.length}, pageSize: ${pageSize}`,
-          {
-            module: 'EntryPoint',
-            method: 'getEntryPoints',
-          }
-        );
-
-        return {
-          data: cachedPage.data,
-          meta: {
-            page,
-            pageSize,
-            totalPages: cachedPage.totalMeta?.totalPages,
-            totalRecords: cachedPage.totalMeta?.totalRecords,
-          },
-        };
-      }
-    }
-
-    // Start timing only for actual API calls (not cache hits)
     this.metricsManager.timeEvent(METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS);
 
     try {
-      // Build query parameters
       const queryParams = new URLSearchParams({
         page: page.toString(),
         pageSize: pageSize.toString(),
-        sortOrder,
+        attributes: mergeEntryPointAttributes(attributes),
       });
 
       if (search) queryParams.append('search', search);
       if (filter) queryParams.append('filter', filter);
-      if (attributes) queryParams.append('attributes', attributes);
-      if (sortBy) queryParams.append('sortBy', sortBy);
+      if (effectiveSortBy) {
+        queryParams.append('sort', `${effectiveSortBy},${sortOrder.toUpperCase()}`);
+      }
+      queryParams.append('desktopProfileFilter', 'true');
+      queryParams.append('includeEntryPointName', 'true');
 
-      const resource = endPointMap.entryPointList(orgId, queryParams.toString());
+      const resource = endPointMap.entryPointDialNumberList(orgId, queryParams.toString());
 
       LoggerProxy.log(
         `Making API request to fetch entry points - resource: ${resource}, service: ${WCC_API_GATEWAY}`,
@@ -162,12 +164,21 @@ export class EntryPoint {
         service: WCC_API_GATEWAY,
         resource,
         method: HTTP_METHODS.GET,
+        headers: {
+          'X-ORGANIZATION-ID': orgId,
+          'x-ignore-internal-data': 'false',
+        },
       });
 
+      const responseBody: EntryPointListResponse = {
+        ...response.body,
+        data: (response.body?.data ?? []).map(mapDialNumberEntryPoint),
+      };
+
       const duration = Date.now() - startTime;
 
-      const recordCount = response.body?.data?.length || 0;
-      const totalRecords = response.body?.meta?.totalRecords;
+      const recordCount = responseBody.data.length;
+      const totalRecords = responseBody.meta?.totalRecords;
 
       LoggerProxy.log(`Successfully retrieved ${recordCount} entry points`, {
         module: 'EntryPoint',
@@ -199,19 +210,7 @@ export class EntryPoint {
         );
       }
 
-      // Cache the page data for simple pagination (no search/filter/attributes/sort)
-      if (this.pageCache.canUseCache({search, filter, attributes, sortBy}) && response.body?.data) {
-        const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
-        this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);
-
-        LoggerProxy.log('Cached entry points data for future requests', {
-          module: 'EntryPoint',
-          method: 'getEntryPoints',
-          data: {cacheKey, recordCount},
-        });
-      }
-
-      return response.body;
+      return responseBody;
     } catch (error) {
       const errorData = {
         orgId,

package/src/services/Queue.ts

@@ -70,14 +70,16 @@ export class Queue {
   }
 
   /**
-   * Fetches contact service queues for the organization
-   * @param {ContactServiceQueueSearchParams} [params] - Search and pagination parameters
+   * Fetches contact service queues for the organization. By default, returns active inbound
+   * telephony queues in backend name-ascending order using the agent's desktop profile views.
+   * Existing filter, sort, and desktop-profile parameters override those defaults.
+   * @param {ContactServiceQueueSearchParams} [params] - Search, pagination, and override parameters
    * @returns {Promise<ContactServiceQueuesResponse>} Promise resolving to contact service queues
    * @throws {Error} If the API call fails
    * @public
    * @example
    * ```typescript
-   * // Get all queues with default pagination
+   * // Get queues using the default list policy and pagination
    * const response = await queueAPI.getQueues();
    *
    * // Get queues with specific pagination
@@ -101,17 +103,29 @@ export class Queue {
       page = PAGINATION_DEFAULTS.PAGE,
       pageSize = PAGINATION_DEFAULTS.PAGE_SIZE,
       search,
-      filter,
+      filter = 'queueType==INBOUND;channelType==TELEPHONY;active==true',
       attributes,
-      sortBy,
-      sortOrder,
-      desktopProfileFilter,
+      sortBy = 'name',
+      sortOrder = 'asc',
+      desktopProfileFilter = true,
       provisioningView,
       singleObjectResponse,
     } = params;
+    const agentView = desktopProfileFilter;
+    const firstLevelView = desktopProfileFilter;
 
     const orgId = this.webex.credentials.getOrgId();
-    const isSearchRequest = !!(search || filter || attributes || sortBy);
+    const effectiveSortBy = sortBy ?? (sortOrder ? 'name' : undefined);
+    const isSearchRequest = !!(search || filter || attributes || effectiveSortBy);
+    const canUseCache = this.pageCache.canUseCache({
+      search,
+      filter,
+      attributes,
+      sortBy: effectiveSortBy,
+      desktopProfileFilter,
+      provisioningView,
+      singleObjectResponse,
+    });
 
     LoggerProxy.info('Fetching contact service queues', {
       module: 'Queue',
@@ -125,7 +139,7 @@ export class Queue {
     });
 
     // Check if we can use cache for simple pagination (no search/filter/attributes/sort)
-    if (this.pageCache.canUseCache({search, filter, attributes, sortBy})) {
+    if (canUseCache) {
       const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
       const cachedPage = this.pageCache.getCachedPage(cacheKey);
 
@@ -170,14 +184,17 @@ export class Queue {
       if (filter) queryParams.append('filter', filter);
       if (attributes) queryParams.append('attributes', attributes);
       if (search) queryParams.append('search', search);
-      if (sortBy) queryParams.append('sortBy', sortBy);
-      if (sortOrder) queryParams.append('sortOrder', sortOrder);
+      if (effectiveSortBy)
+        queryParams.append('sort', `${effectiveSortBy},${(sortOrder ?? 'asc').toUpperCase()}`);
       if (desktopProfileFilter !== undefined)
         queryParams.append('desktopProfileFilter', desktopProfileFilter.toString());
       if (provisioningView !== undefined)
         queryParams.append('provisioningView', provisioningView.toString());
       if (singleObjectResponse !== undefined)
         queryParams.append('singleObjectResponse', singleObjectResponse.toString());
+      if (agentView !== undefined) queryParams.append('agentView', agentView.toString());
+      if (firstLevelView !== undefined)
+        queryParams.append('firstLevelView', firstLevelView.toString());
 
       const resource = endPointMap.queueList(orgId, queryParams.toString());
 
@@ -232,7 +249,7 @@ export class Queue {
       }
 
       // Cache the page data for simple pagination (no search/filter/attributes/sort)
-      if (this.pageCache.canUseCache({search, filter, attributes, sortBy}) && response.body?.data) {
+      if (canUseCache && response.body?.data) {
         const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
         this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);