@webex/contact-center 3.12.0-next.147 → 3.12.0-next.148

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

@@ -14,9 +14,14 @@ import {
   isSecondaryEpDnAgent,
   getConsultMediaResourceId,
   getIsConsultInProgressForConferenceControls,
+  getIsConsultedAgentForControls,
+  getServerHoldStateForControls,
+  isCampaignPreviewTask,
+  isCampaignPreviewReservation,
 } from '../../../../../src/services/task/TaskUtils';
 import {ITask, Interaction, TaskData} from '../../../../../src/services/task/types';
 import {LoginOption} from '../../../../../src/types';
+import {CC_EVENTS} from '../../../../../src/services/config/types';
 
 describe('TaskUtils', () => {
   let mockTask: ITask;
@@ -47,6 +52,73 @@ describe('TaskUtils', () => {
     } as any;
   });
 
+  describe('state-control helper branches', () => {
+    it('should derive consulted-agent and hold states from task context', () => {
+      expect(
+        getIsConsultedAgentForControls({isConsulted: true} as TaskData, {} as any, false)
+      ).toBe(true);
+      expect(
+        getIsConsultedAgentForControls(
+          {} as TaskData,
+          {consultInitiator: false} as any,
+          true
+        )
+      ).toBe(true);
+      expect(
+        getIsConsultedAgentForControls(
+          {} as TaskData,
+          {consultInitiator: true} as any,
+          true
+        )
+      ).toBe(false);
+
+      const taskData = {
+        interaction: {
+          media: {
+            main: {isHold: true},
+            fallback: {isHold: false},
+          },
+        },
+        mediaResourceId: 'fallback',
+      } as TaskData;
+
+      expect(getServerHoldStateForControls({taskData} as any, 'main')).toBe(true);
+      expect(getServerHoldStateForControls({taskData} as any)).toBe(false);
+      expect(getServerHoldStateForControls({} as any)).toBeUndefined();
+    });
+
+    it('should detect campaign preview tasks and reservations', () => {
+      expect(
+        isCampaignPreviewTask({
+          interaction: {
+            outboundType: 'STANDARD_PREVIEW_CAMPAIGN',
+            callProcessingDetails: {},
+          },
+        } as TaskData)
+      ).toBe(true);
+      expect(
+        isCampaignPreviewTask({
+          interaction: {
+            outboundType: 'OUTDIAL',
+            callProcessingDetails: {campaignType: 'preview_standard'},
+          },
+        } as unknown as TaskData)
+      ).toBe(true);
+      expect(isCampaignPreviewTask({interaction: {callProcessingDetails: {}}} as TaskData)).toBe(
+        false
+      );
+
+      expect(
+        isCampaignPreviewReservation({
+          data: {type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION},
+        } as ITask)
+      ).toBe(true);
+      expect(isCampaignPreviewReservation({data: {type: CC_EVENTS.AGENT_CONTACT}} as ITask)).toBe(
+        false
+      );
+    });
+  });
+
   describe('isPrimary', () => {
     it('should return true when agent is the owner', () => {
       expect(isPrimary(mockTask, mockAgentId)).toBe(true);

package/test/unit/spec/services/task/voice/Voice.ts

@@ -3,6 +3,7 @@ import LoggerProxy from '../../../../../../src/logger-proxy';
 import {
   TaskData,
   CONSULT_TRANSFER_DESTINATION_TYPE,
+  DESTINATION_TYPE,
   TASK_EVENTS,
   VOICE_VARIANT,
 } from '../../../../../../src/services/task/types';
@@ -11,6 +12,10 @@ import {TaskEvent, TaskState} from '../../../../../../src/services/task/state-ma
 import {computeUIControls} from '../../../../../../src/services/task/state-machine/uiControlsComputer';
 import * as Utils from '../../../../../../src/services/core/Utils';
 import {createTaskData} from '../taskTestUtils';
+import {AIAssistantEventName} from '../../../../../../src/types';
+import {AI_SUMMARY_ERROR_CODES} from '../../../../../../src/constants';
+import {AI_SUMMARY_REQUEST_CANCELLED} from '../../../../../../src/services/task/constants';
+import {createAISummaryError, flushMicrotasks} from '../../../../fixtures/aiSummaryTestUtils';
 import MetricsManager from '../../../../../../src/metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../../../../src/metrics/constants';
 import * as wxAppDiagnosticLogging from '../../../../../../src/services/wxAppDiagnosticLogging';
@@ -104,9 +109,7 @@ describe('Voice Task', () => {
         reason: 'CUSTOMER_BUSY',
       });
 
-      const outdialFailedCall = emitSpy.mock.calls.find(
-        (call) => call[0] === 'task:outdialFailed'
-      );
+      const outdialFailedCall = emitSpy.mock.calls.find((call) => call[0] === 'task:outdialFailed');
       expect(outdialFailedCall).toBeDefined();
       expect(outdialFailedCall![1]).toBe('CUSTOMER_BUSY');
     });
@@ -127,9 +130,7 @@ describe('Voice Task', () => {
         reason: 'AGENT_ENDS',
       });
 
-      const outdialFailedCall = emitSpy.mock.calls.find(
-        (call) => call[0] === 'task:outdialFailed'
-      );
+      const outdialFailedCall = emitSpy.mock.calls.find((call) => call[0] === 'task:outdialFailed');
       expect(outdialFailedCall).toBeUndefined();
     });
   });
@@ -211,7 +212,10 @@ describe('Voice Task', () => {
     }) as any;
     const voice = new Voice(dummyContact, heldConferenceData, {});
     primeConnectedState(voice, heldConferenceData);
-    voice.stateMachineService?.send({type: TaskEvent.CONFERENCE_START, taskData: heldConferenceData});
+    voice.stateMachineService?.send({
+      type: TaskEvent.CONFERENCE_START,
+      taskData: heldConferenceData,
+    });
     expect(voice.stateMachineService?.getSnapshot().value).toBe(TaskState.CONFERENCING);
 
     await voice.holdResume();
@@ -598,6 +602,341 @@ describe('Voice Task', () => {
     });
   });
 
+  describe('AI summary noninterference for call controls', () => {
+    const summaryAgentId = 'summary-agent-1';
+    const wrapupPayload = {wrapUpReason: 'Customer resolved', auxCodeId: 'wrapup-code-1'} as const;
+    const consultPayload = {
+      to: 'consult-agent-1',
+      destinationType: DESTINATION_TYPE.AGENT,
+      holdParticipants: true,
+    } as const;
+    const transferPayload = {
+      to: 'transfer-agent-1',
+      destinationType: DESTINATION_TYPE.AGENT,
+    } as const;
+    const callControlMethods = [
+      'wrapup',
+      'consult',
+      'blindTransfer',
+      'vteamTransfer',
+      'consultTransfer',
+    ] as const;
+    type CallControlMethod = (typeof callControlMethods)[number];
+    type CallControlCase = {
+      label: string;
+      createOperationResult: () => unknown;
+      expectedContactCalls: Record<CallControlMethod, unknown[][]>;
+      prime: (voice: Voice, taskData: TaskData) => void;
+      invoke: (voice: Voice) => Promise<unknown>;
+      requestSummary: (voice: Voice) => Promise<unknown>;
+      summaryEventName: AIAssistantEventName;
+    };
+
+    const createContactMock = (operationResult: any) =>
+      ({
+        hold: jest.fn().mockResolvedValue('held'),
+        unHold: jest.fn().mockResolvedValue('resumed'),
+        pauseRecording: jest.fn().mockResolvedValue('paused'),
+        resumeRecording: jest.fn().mockResolvedValue('resumedRecording'),
+        wrapup: jest.fn().mockResolvedValue(operationResult),
+        consult: jest.fn().mockResolvedValue(operationResult),
+        blindTransfer: jest.fn().mockResolvedValue(operationResult),
+        vteamTransfer: jest.fn().mockResolvedValue(operationResult),
+        consultTransfer: jest.fn().mockResolvedValue(operationResult),
+      } as any);
+
+    const createSummaryAdapter = () => {
+      let rejectPending: ((error: Error) => void) | undefined;
+      const adapter: any = {
+        sendEvent: jest.fn().mockResolvedValue(undefined),
+        requestAndWaitForRtd: jest.fn(async (options: any) => {
+          const result = new Promise((_resolve, reject) => {
+            rejectPending = reject;
+          });
+          await adapter.sendEvent(
+            options.agentId,
+            options.interactionId,
+            options.eventType,
+            options.eventName,
+            options.eventMetaData,
+            undefined,
+            undefined,
+            Date.now(),
+            options.timeout
+          );
+          return result;
+        }),
+        clear: jest.fn(() =>
+          rejectPending?.(createAISummaryError(AI_SUMMARY_REQUEST_CANCELLED))
+        ),
+      };
+
+      return adapter;
+    };
+
+    const injectAISummaryDependencies = (
+      voice: Voice,
+      adapter = createSummaryAdapter(),
+      featureEnablement = {
+        interactionId: 'int1',
+        postCallEnabled: true,
+        midCallEnabled: true,
+      }
+    ) => {
+      adapter.aiFeature = {
+        id: 'summary-flags',
+        generatedSummaries: {
+          wrapUpSummariesEnabled: true,
+          consultTransferSummariesEnabled: true,
+        },
+      };
+      (voice as any).apiAIAssistant = adapter;
+      voice.setFeatureEnablement(featureEnablement);
+
+      return {adapter, coordinator: adapter};
+    };
+
+    const normalizeEmitCalls = (emitSpy: jest.SpyInstance, voice: Voice) =>
+      emitSpy.mock.calls.map(([eventName, ...args]) => [
+        eventName,
+        ...args.map((arg) => (arg === voice ? 'VOICE_SELF' : arg)),
+      ]);
+
+    const getContactCalls = (contact: any) =>
+      callControlMethods.reduce((calls, method) => {
+        calls[method] = contact[method].mock.calls;
+
+        return calls;
+      }, {} as Record<CallControlMethod, unknown[][]>);
+
+    const createVoiceHarness = (testCase: CallControlCase) => {
+      const taskData = createBaseData();
+      const operationResult = testCase.createOperationResult();
+      const contact = createContactMock(operationResult);
+      const voice = new Voice(
+        contact,
+        taskData,
+        {isEndTaskEnabled: true, isEndConsultEnabled: true},
+        undefined,
+        summaryAgentId
+      );
+
+      testCase.prime(voice, taskData);
+      const emitSpy = jest.spyOn(voice, 'emit');
+
+      return {contact, emitSpy, operationResult, taskData, voice};
+    };
+
+    const captureCallControlOutcome = (
+      harness: ReturnType<typeof createVoiceHarness>,
+      result: unknown
+    ) => {
+      const snapshot = harness.voice.stateMachineService?.getSnapshot();
+
+      return {
+        contactCalls: getContactCalls(harness.contact),
+        emitCalls: normalizeEmitCalls(harness.emitSpy, harness.voice),
+        result,
+        state: snapshot?.value,
+        context: snapshot?.context,
+        uiControls: harness.voice.uiControls,
+      };
+    };
+
+    const runCallControl = async (testCase: CallControlCase) => {
+      const harness = createVoiceHarness(testCase);
+      const result = await testCase.invoke(harness.voice);
+
+      expect(result).toBe(harness.operationResult);
+
+      return captureCallControlOutcome(harness, result);
+    };
+
+    const callControlCases: CallControlCase[] = [
+      {
+        label: 'wrapup',
+        createOperationResult: () => ({
+          trackingId: 'wrapup-tracking-1',
+          data: {wrappedUp: true},
+        }),
+        expectedContactCalls: {
+          wrapup: [[{interactionId: 'int1', data: wrapupPayload}]],
+          consult: [],
+          blindTransfer: [],
+          vteamTransfer: [],
+          consultTransfer: [],
+        },
+        prime: primeConnectedState,
+        invoke: (voice: Voice) => voice.wrapup({...wrapupPayload}),
+        requestSummary: (voice: Voice) => voice.requestPostCallSummary(),
+        summaryEventName: AIAssistantEventName.GET_POST_CALL_SUMMARY,
+      },
+      {
+        label: 'consult',
+        createOperationResult: () => ({
+          trackingId: 'consult-tracking-1',
+          data: createBaseData({
+            destinationType: DESTINATION_TYPE.AGENT,
+            destAgentId: 'consult-agent-1',
+            interaction: {state: 'consulting'} as any,
+          }),
+        }),
+        expectedContactCalls: {
+          wrapup: [],
+          consult: [[{interactionId: 'int1', data: consultPayload}]],
+          blindTransfer: [],
+          vteamTransfer: [],
+          consultTransfer: [],
+        },
+        prime: primeConnectedState,
+        invoke: (voice: Voice) => voice.consult({...consultPayload}),
+        requestSummary: (voice: Voice) => voice.requestMidCallSummary('CONSULT'),
+        summaryEventName: AIAssistantEventName.GET_MID_CALL_CONSULT_SUMMARY,
+      },
+      {
+        label: 'transfer',
+        createOperationResult: () => ({
+          trackingId: 'transfer-tracking-1',
+          data: {transferred: true},
+        }),
+        expectedContactCalls: {
+          wrapup: [],
+          consult: [],
+          blindTransfer: [[{interactionId: 'int1', data: transferPayload}]],
+          vteamTransfer: [],
+          consultTransfer: [],
+        },
+        prime: primeConnectedState,
+        invoke: (voice: Voice) => voice.transfer({...transferPayload}),
+        requestSummary: (voice: Voice) => voice.requestMidCallSummary('TRANSFER'),
+        summaryEventName: AIAssistantEventName.GET_MID_CALL_TRANSFER_SUMMARY,
+      },
+    ];
+
+    const expectSummaryGetRequest = (
+      adapter: ReturnType<typeof createSummaryAdapter>,
+      summaryEventName: AIAssistantEventName
+    ) => {
+      expect(adapter.sendEvent).toHaveBeenCalledTimes(1);
+      expect(adapter.sendEvent).toHaveBeenCalledWith(
+        summaryAgentId,
+        'int1',
+        'CTI_EVENT',
+        summaryEventName,
+        expect.objectContaining({
+          conversationId: 'int1',
+          clientType: 'WxCC',
+        }),
+        undefined,
+        undefined,
+        expect.any(Number),
+        15000
+      );
+    };
+
+    const expectCancelledSummary = async (summaryRequest: Promise<unknown>) => {
+      await expect(summaryRequest).rejects.toMatchObject({
+        message: AI_SUMMARY_REQUEST_CANCELLED,
+        data: {errorCode: AI_SUMMARY_REQUEST_CANCELLED},
+      });
+    };
+
+    const summaryActivityCases = [
+      {
+        label: 'while the matching AI summary request is pending',
+        prepare: async (harness: VoiceHarnessWithCase) => {
+          const {adapter, coordinator} = injectAISummaryDependencies(harness.voice);
+          const summaryRequest = harness.testCase.requestSummary(harness.voice);
+          const summaryObserver = jest.fn();
+
+          summaryRequest.then(summaryObserver, summaryObserver);
+          await flushMicrotasks();
+
+          expectSummaryGetRequest(adapter, harness.testCase.summaryEventName);
+          expect(summaryObserver).not.toHaveBeenCalled();
+
+          return async () => {
+            expect(summaryObserver).not.toHaveBeenCalled();
+            coordinator.clear('int1', 'int1');
+            await expectCancelledSummary(summaryRequest);
+          };
+        },
+      },
+      {
+        label: 'after coordinator owner cancellation',
+        prepare: async (harness: VoiceHarnessWithCase) => {
+          const {adapter, coordinator} = injectAISummaryDependencies(harness.voice);
+          const summaryRequest = harness.testCase.requestSummary(harness.voice);
+
+          await flushMicrotasks();
+          expectSummaryGetRequest(adapter, harness.testCase.summaryEventName);
+
+          coordinator.clear('int1', 'int1');
+          await expectCancelledSummary(summaryRequest);
+
+          return async () => undefined;
+        },
+      },
+      {
+        label: 'after adapter rejection',
+        prepare: async (harness: VoiceHarnessWithCase) => {
+          const adapter = createSummaryAdapter();
+          const adapterError = createAISummaryError(
+            AI_SUMMARY_ERROR_CODES.AI_ASSISTANT_BASE_URL_NOT_AVAILABLE
+          );
+
+          adapter.sendEvent.mockRejectedValueOnce(adapterError);
+          injectAISummaryDependencies(harness.voice, adapter);
+
+          await expect(harness.testCase.requestSummary(harness.voice)).rejects.toBe(adapterError);
+          expectSummaryGetRequest(adapter, harness.testCase.summaryEventName);
+
+          return async () => undefined;
+        },
+      },
+    ];
+
+    type VoiceHarnessWithCase = ReturnType<typeof createVoiceHarness> & {
+      testCase: CallControlCase;
+    };
+
+    const createVoiceHarnessWithCase = (testCase: CallControlCase): VoiceHarnessWithCase => ({
+      ...createVoiceHarness(testCase),
+      testCase,
+    });
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.clearAllTimers();
+      jest.useRealTimers();
+    });
+
+    describe.each(summaryActivityCases)('$label', (summaryActivity) => {
+      it.each(callControlCases)(
+        '$label preserves contact arguments, resolved value, and task events',
+        async (testCase) => {
+          const baseline = await runCallControl(testCase);
+          const harness = createVoiceHarnessWithCase(testCase);
+          const finalizeSummaryActivity = await summaryActivity.prepare(harness);
+
+          try {
+            const result = await testCase.invoke(harness.voice);
+            const observed = captureCallControlOutcome(harness, result);
+
+            expect(result).toBe(harness.operationResult);
+            expect(observed.contactCalls).toEqual(testCase.expectedContactCalls);
+            expect(observed).toEqual(baseline);
+          } finally {
+            await finalizeSummaryActivity();
+          }
+        }
+      );
+    });
+  });
+
   describe('exitConference()', () => {
     const conferenceTaskData = () =>
       createBaseData({
@@ -951,13 +1290,7 @@ describe('Voice Task', () => {
       ['number', 503],
     ])('records failure telemetry and preserves a %s rejection', async (_label, failure) => {
       dummyContact.dropConferenceParticipant.mockRejectedValueOnce(failure);
-      const voice = new Voice(
-        dummyContact,
-        createBaseData(),
-        {},
-        undefined,
-        'current-agent-id'
-      );
+      const voice = new Voice(dummyContact, createBaseData(), {}, undefined, 'current-agent-id');
       const metricsManager = MetricsManager.getInstance();
       const failureFieldsSpy = jest.spyOn(
         MetricsManager,
@@ -967,9 +1300,9 @@ describe('Voice Task', () => {
       const trackEventSpy = jest.spyOn(metricsManager, 'trackEvent').mockImplementation();
       const errorSpy = jest.spyOn(LoggerProxy, 'error').mockImplementation();
 
-      await expect(
-        voice.dropConferenceParticipant({participantId: 'participant-id'})
-      ).rejects.toBe(failure);
+      await expect(voice.dropConferenceParticipant({participantId: 'participant-id'})).rejects.toBe(
+        failure
+      );
 
       expect(failureFieldsSpy).toHaveBeenCalledWith({});
       expect(trackEventSpy).toHaveBeenCalledWith(
@@ -1057,7 +1390,9 @@ describe('Voice Task', () => {
 
       voice.applyWxAppMuteStateFromSync('prefix:call-id-1', true);
 
-      expect(emitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_WXAPP_MUTE_STATE_UPDATED, {muted: true});
+      expect(emitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_WXAPP_MUTE_STATE_UPDATED, {
+        muted: true,
+      });
     });
 
     it('no-ops when callId does not match active call', () => {