@webex/contact-center 3.12.0-next.12 → 3.12.0-next.121

package/test/unit/spec/services/ApiAiAssistant.ts

@@ -1,7 +1,8 @@
 import ApiAIAssistant from '../../../../src/services/ApiAiAssistant';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
 import LoggerProxy from '../../../../src/logger-proxy';
-import {HTTP_METHODS, WebexSDK} from '../../../../src/types';
+import WebexRequest from '../../../../src/services/core/WebexRequest';
+import {HTTP_METHODS, RealTimeAssistanceUserActionId, WebexSDK} from '../../../../src/types';
 
 jest.mock('../../../../src/metrics/MetricsManager');
 jest.mock('../../../../src/logger-proxy');
@@ -13,6 +14,9 @@ describe('ApiAIAssistant', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    jest.spyOn(WebexRequest, 'getInstance').mockReturnValue({
+      uploadLogs: jest.fn(),
+    } as any);
 
     mockWebex = {
       credentials: {
@@ -50,26 +54,21 @@ describe('ApiAIAssistant', () => {
       'interaction-1',
       'CUSTOM_EVENT',
       'GET_TRANSCRIPTS',
-      'START'
+      {action: 'START'}
     );
 
-    expect(mockWebex.request).toHaveBeenCalledWith({
-      uri: 'https://api-ai-assistant.produs1.ciscoccservice.com/event',
-      method: HTTP_METHODS.POST,
-      addAuthHeader: true,
-      body: {
-        agentId: 'test-agent-id',
-        orgId: 'test-org-id',
-        eventType: 'CUSTOM_EVENT',
-        eventName: 'GET_TRANSCRIPTS',
-        eventDetails: {
-          data: expect.objectContaining({
-            interactionId: 'interaction-1',
-            action: 'START',
-          }),
-        },
-      },
-    });
+    expect(mockWebex.request).toHaveBeenCalledTimes(1);
+    const requestArgs = (mockWebex.request as jest.Mock).mock.calls[0][0];
+
+    expect(requestArgs.uri).toBe('https://api-ai-assistant.produs1.ciscoccservice.com/event');
+    expect(requestArgs.method).toBe(HTTP_METHODS.POST);
+    expect(requestArgs.addAuthHeader).toBe(true);
+    expect(requestArgs.body.agentId).toBe('test-agent-id');
+    expect(requestArgs.body.orgId).toBe('test-org-id');
+    expect(requestArgs.body.eventType).toBe('CUSTOM_EVENT');
+    expect(requestArgs.body.eventName).toBe('GET_TRANSCRIPTS');
+    expect(requestArgs.body.eventDetails.data.interactionId).toBe('interaction-1');
+    expect(requestArgs.body.eventDetails.data.action).toBe('START');
     expect(result).toEqual({ok: true});
   });
 
@@ -93,6 +92,118 @@ describe('ApiAIAssistant', () => {
     expect(result).toEqual(responseBody as any);
   });
 
+  it('should request real-time assistance without extra context using sendEvent', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getRealTimeAssistance({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, metadata, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('GET_SUGGESTIONS');
+    expect(metadata).toBeUndefined();
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
+  it('should request real-time assistance with extra context using sendEvent', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getRealTimeAssistance({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+      context: 'Need assistance with credit card payment due date',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, metadata, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('ADD_SUGGESTIONS_EXTRA_CONTEXT');
+    expect(metadata).toEqual({context: 'Need assistance with credit card payment due date'});
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
+  it('should treat whitespace-only context as GET_SUGGESTIONS', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getRealTimeAssistance({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+      context: '   ',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, metadata, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('GET_SUGGESTIONS');
+    expect(metadata).toEqual({context: ''});
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
+  [
+    RealTimeAssistanceUserActionId.LIKE,
+    RealTimeAssistanceUserActionId.DISLIKE,
+    RealTimeAssistanceUserActionId.COPY,
+  ].forEach((actionId) => {
+    it(`should send real-time assistance user action for ${actionId}`, async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue({body: {ok: true}});
+      apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+      const result = await apiAIAssistant.sendRealTimeAssistanceUserAction({
+        agentId: 'test-agent-id',
+        interactionId: 'interaction-1',
+        adaptiveCardId: 'adaptive-card-1',
+        actionId,
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(1);
+      const requestArgs = (mockWebex.request as jest.Mock).mock.calls[0][0];
+      const eventData = requestArgs.body.eventDetails.data;
+
+      expect(requestArgs.uri).toBe('https://api-ai-assistant.produs1.ciscoccservice.com/event');
+      expect(requestArgs.method).toBe(HTTP_METHODS.POST);
+      expect(requestArgs.addAuthHeader).toBe(true);
+      expect(requestArgs.body.agentId).toBe('test-agent-id');
+      expect(requestArgs.body.orgId).toBe('test-org-id');
+      expect(requestArgs.body.eventType).toBe('CUSTOM_EVENT');
+      expect(requestArgs.body.eventName).toBe('SUGGESTED_RESPONSES_USER_ACTION');
+      expect(eventData.interactionId).toBe('interaction-1');
+      expect(eventData.adaptiveCardId).toBe('adaptive-card-1');
+      expect(eventData.userAction.actionType).toBe('Action.Submit');
+      expect(eventData.userAction.actionId).toBe(actionId);
+      expect(eventData.languageCode).toBe('en');
+      expect(typeof eventData.actionTimeStamp).toBe('string');
+      expect(eventData.trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+      expect(result).toEqual({ok: true});
+    });
+  });
+
   it('should fail when base URL mapping is not available', async () => {
     (mockWebex.internal.services.get as jest.Mock).mockReturnValue('https://unknown-host.invalid');
 
@@ -103,7 +214,7 @@ describe('ApiAIAssistant', () => {
         'interaction-1',
         'CUSTOM_EVENT',
         'GET_TRANSCRIPTS',
-        'STOP'
+        {action: 'STOP'}
       );
     } catch (_error) {
       failed = true;
@@ -112,4 +223,51 @@ describe('ApiAIAssistant', () => {
     expect(failed).toBe(true);
     expect(LoggerProxy.error).toHaveBeenCalled();
   });
+
+  it('should fail when realtime transcripts feature is disabled', async () => {
+    apiAIAssistant.setAIFeatureFlags({realtimeTranscripts: {enable: false}} as any);
+    let errorMessage = '';
+
+    try {
+      await apiAIAssistant.fetchHistoricTranscripts('test-agent-id', 'interaction-1');
+    } catch (error) {
+      errorMessage = (error as Error)?.message || '';
+    }
+
+    expect(errorMessage).toBe('Error while performing fetchHistoricTranscripts');
+  });
+
+  it('should fail when real-time assistance feature is disabled', async () => {
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: false}} as any);
+    let errorMessage = '';
+
+    try {
+      await apiAIAssistant.getRealTimeAssistance({
+        agentId: 'test-agent-id',
+        interactionId: 'interaction-1',
+      });
+    } catch (error) {
+      errorMessage = (error as Error)?.message || '';
+    }
+
+    expect(errorMessage).toBe('Error while performing getRealTimeAssistance');
+  });
+
+  it('should fail to send real-time assistance user action when feature is disabled', async () => {
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: false}} as any);
+    let errorMessage = '';
+
+    try {
+      await apiAIAssistant.sendRealTimeAssistanceUserAction({
+        agentId: 'test-agent-id',
+        interactionId: 'interaction-1',
+        adaptiveCardId: 'adaptive-card-1',
+        actionId: RealTimeAssistanceUserActionId.LIKE,
+      });
+    } catch (error) {
+      errorMessage = (error as Error)?.message || '';
+    }
+
+    expect(errorMessage).toBe('Error while performing sendRealTimeAssistanceUserAction');
+  });
 });

package/test/unit/spec/services/EntryPoint.ts

@@ -1,5 +1,5 @@
 import EntryPoint from '../../../../src/services/EntryPoint';
-import {HTTP_METHODS, WebexSDK, IHttpResponse} from '../../../../src/types';
+import {HTTP_METHODS, WebexSDK, IHttpResponse, EntryPointRecord} from '../../../../src/types';
 import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
 import WebexRequest from '../../../../src/services/core/WebexRequest';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
@@ -50,30 +50,38 @@ describe('EntryPoint', () => {
   });
 
   describe('getEntryPoints', () => {
-    const mockEntryPoints = [
+    const mockDialNumberMappings = [
       {
-        id: 'entry1',
-        name: 'Test Entry Point 1',
-        type: 'voice',
-        isActive: true,
-        orgId: 'test-org-id',
+        id: 'dial-number-1',
+        dialledNumber: '+1-555-0101',
+        entryPointId: 'entry1',
+        entryPointName: 'Test Entry Point 1',
       },
       {
-        id: 'entry2',
-        name: 'Test Entry Point 2',
-        type: 'chat',
-        isActive: true,
-        orgId: 'test-org-id',
+        id: 'dial-number-2',
+        dialledNumber: '+1-555-0102',
+        entryPointId: 'entry2',
+        entryPointName: 'Test Entry Point 2',
       },
     ];
+    const expectedEntryPoints: EntryPointRecord[] = [
+      {id: 'entry1', name: 'Test Entry Point 1', number: '+1-555-0101'},
+      {id: 'entry2', name: 'Test Entry Point 2', number: '+1-555-0102'},
+    ];
+    const defaultResource =
+      '/organization/test-org-id/v3/dial-number?page=0&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true';
+    const requestHeaders = {
+      'X-ORGANIZATION-ID': 'test-org-id',
+      'x-ignore-internal-data': 'false',
+    };
 
     const mockResponse: IHttpResponse = {
       statusCode: 200,
       method: 'GET',
-      url: '/organization/test-org-id/v2/entry-point',
+      url: '/organization/test-org-id/v3/dial-number',
       headers: {} as any,
       body: {
-        data: mockEntryPoints,
+        data: mockDialNumberMappings,
         meta: {
           page: 0,
           pageSize: 100,
@@ -99,11 +107,14 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc',
+        resource: defaultResource,
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
-      expect(result).toEqual(mockResponse.body);
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
+      expect(result.data[0].number).toBe('+1-555-0101');
       expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS);
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
@@ -122,7 +133,7 @@ describe('EntryPoint', () => {
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
       expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Making API request to fetch entry points - resource: /organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc, service: wcc-api-gateway`,
+        `Making API request to fetch entry points - resource: ${defaultResource}, service: wcc-api-gateway`,
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
     });
@@ -134,7 +145,7 @@ describe('EntryPoint', () => {
         page: 1,
         pageSize: 25,
         search: 'test',
-        filter: 'type=="voice"',
+        filter: 'entryPointId=="entry1"',
         attributes: 'id,name',
         sortBy: 'name',
         sortOrder: 'desc' as const,
@@ -144,8 +155,11 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=1&pageSize=25&sortOrder=desc&search=test&filter=type%3D%3D%22voice%22&attributes=id%2Cname&sortBy=name',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=25&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName%2Cname&search=test&filter=entryPointId%3D%3D%22entry1%22&sort=entryPointName%2CDESC&desktopProfileFilter=true&includeEntryPointName=true',
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
@@ -162,6 +176,41 @@ describe('EntryPoint', () => {
       );
     });
 
+    it('should allow existing parameters to override the default entry-point mapping policy', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await entryPointAPI.getEntryPoints({
+        page: 1,
+        pageSize: 25,
+        search: 'sales',
+        filter: 'entryPointId==entry1',
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=25&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&search=sales&filter=entryPointId%3D%3Dentry1&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true',
+        method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
+      });
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
+    });
+
+    it('should issue every profile-scoped request directly', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await entryPointAPI.getEntryPoints();
+      await entryPointAPI.getEntryPoints();
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          resource: expect.stringContaining('desktopProfileFilter=true'),
+        })
+      );
+    });
+
     it('should handle API errors and track metrics', async () => {
       (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
 
@@ -169,8 +218,10 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc',
+        resource: defaultResource,
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
@@ -187,22 +238,24 @@ describe('EntryPoint', () => {
       expect(LoggerProxy.error).toHaveBeenCalled();
     });
 
-
-
-    it('should not track metrics for subsequent pages in simple pagination', async () => {
+    it('should not track success metrics for subsequent pages under the default mapping policy', async () => {
       (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
 
       const result = await entryPointAPI.getEntryPoints({page: 2});
-      expect(result).toEqual(mockResponse.body);
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
 
-      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
+        expect.anything(),
+        expect.anything()
+      );
     });
 
     it('should track metrics for search requests on any page', async () => {
       (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
 
       const result2 = await entryPointAPI.getEntryPoints({page: 2, search: 'test'});
-      expect(result2).toEqual(mockResponse.body);
+      expect(result2).toEqual({...mockResponse.body, data: expectedEntryPoints});
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
@@ -218,15 +271,11 @@ describe('EntryPoint', () => {
       );
     });
 
-    it('should call API when requested page is not cached (cache miss)', async () => {
-      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponse);
-
-      await entryPointAPI.getEntryPoints({page: 0});
-
-      (mockWebex.request as jest.Mock).mockResolvedValueOnce({
+    it('should request the specified page', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue({
         ...mockResponse,
         body: {
-          data: mockEntryPoints,
+          data: mockDialNumberMappings,
           meta: {
             page: 1,
             pageSize: 100,
@@ -237,21 +286,19 @@ describe('EntryPoint', () => {
         },
       });
 
-      const callsBefore = (mockWebex.request as jest.Mock).mock.calls.length;
-      (LoggerProxy.log as jest.Mock).mockClear();
-
       const result = await entryPointAPI.getEntryPoints({page: 1});
-      const callsAfter = (mockWebex.request as jest.Mock).mock.calls.length;
 
-      expect(callsAfter).toBe(callsBefore + 1);
       expect(result.meta.page).toBe(1);
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=1&pageSize=100&sortOrder=asc',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true',
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
       expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Making API request to fetch entry points - resource: /organization/test-org-id/v2/entry-point?page=1&pageSize=100&sortOrder=asc, service: wcc-api-gateway`,
+        `Making API request to fetch entry points - resource: /organization/test-org-id/v3/dial-number?page=1&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true, service: wcc-api-gateway`,
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
     });