@webex/contact-center 3.12.0-next.85 → 3.12.0-next.87

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

@@ -2,7 +2,7 @@ import ApiAIAssistant from '../../../../src/services/ApiAiAssistant';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
 import LoggerProxy from '../../../../src/logger-proxy';
 import WebexRequest from '../../../../src/services/core/WebexRequest';
-import {HTTP_METHODS, WebexSDK} from '../../../../src/types';
+import {HTTP_METHODS, RealTimeAssistanceUserActionId, WebexSDK} from '../../../../src/types';
 
 jest.mock('../../../../src/metrics/MetricsManager');
 jest.mock('../../../../src/logger-proxy');
@@ -54,7 +54,7 @@ describe('ApiAIAssistant', () => {
       'interaction-1',
       'CUSTOM_EVENT',
       'GET_TRANSCRIPTS',
-      'START'
+      {action: 'START'}
     );
 
     expect(mockWebex.request).toHaveBeenCalledTimes(1);
@@ -92,51 +92,49 @@ describe('ApiAIAssistant', () => {
     expect(result).toEqual(responseBody as any);
   });
 
-  it('should request suggested response without extra context using sendEvent', async () => {
+  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.getSuggestedResponse({
+    const result = await apiAIAssistant.getRealTimeAssistance({
       agentId: 'test-agent-id',
       interactionId: 'interaction-1',
     });
 
     expect(sendEventSpy).toHaveBeenCalledTimes(1);
-    const [agentId, interactionId, eventType, eventName, action, context, languageCode, trackingId] =
+    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(action).toBeUndefined();
-    expect(context).toBeUndefined();
+    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 suggested response with extra context using sendEvent', async () => {
+  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.getSuggestedResponse({
+    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, action, context, languageCode, trackingId] =
+    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(action).toBeUndefined();
-    expect(context).toBe('Need assistance with credit card payment due date');
+    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);
@@ -147,28 +145,65 @@ describe('ApiAIAssistant', () => {
     const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
     apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
 
-    const result = await apiAIAssistant.getSuggestedResponse({
+    const result = await apiAIAssistant.getRealTimeAssistance({
       agentId: 'test-agent-id',
       interactionId: 'interaction-1',
       context: '   ',
     });
 
     expect(sendEventSpy).toHaveBeenCalledTimes(1);
-    const [agentId, interactionId, eventType, eventName, action, context, languageCode, trackingId] =
+    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(action).toBeUndefined();
-    expect(context).toBe('');
+    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');
 
@@ -179,7 +214,7 @@ describe('ApiAIAssistant', () => {
         'interaction-1',
         'CUSTOM_EVENT',
         'GET_TRANSCRIPTS',
-        'STOP'
+        {action: 'STOP'}
       );
     } catch (_error) {
       failed = true;
@@ -202,19 +237,37 @@ describe('ApiAIAssistant', () => {
     expect(errorMessage).toBe('Error while performing fetchHistoricTranscripts');
   });
 
-  it('should fail when suggested responses feature is disabled', async () => {
+  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.getSuggestedResponse({
+      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 getSuggestedResponse');
+    expect(errorMessage).toBe('Error while performing sendRealTimeAssistanceUserAction');
   });
 });

package/test/unit/spec/services/task/TaskManager.ts

@@ -293,14 +293,14 @@ describe('TaskManager', () => {
       interactionId,
       'CUSTOM_EVENT',
       'GET_TRANSCRIPTS',
-      'START'
+      {action: 'START'}
     );
     expect(mockApiAIAssistant.sendEvent).toHaveBeenCalledWith(
       'test-agent-id',
       interactionId,
       'CUSTOM_EVENT',
       'GET_TRANSCRIPTS',
-      'STOP'
+      {action: 'STOP'}
     );
   });