@webex/contact-center 3.12.0-llmrefactor.11 → 3.12.0-llmrefactor.13

package/test/unit/spec/cc.ts

@@ -130,6 +130,7 @@ describe('webex.cc', () => {
       config: {
         getAgentConfig: jest.fn(),
         getOutdialAniEntries: jest.fn(),
+        getWellbeingBreakIdleCode: jest.fn(),
       },
       webSocketManager: mockWebSocketManager,
       rtdWebSocketManager: {
@@ -321,6 +322,7 @@ describe('webex.cc', () => {
       isTimeoutDesktopInactivityEnabled: false,
       webRtcEnabled: true,
       lostConnectionRecoveryTimeout: 0,
+      isWellnessBreakEnabled: false,
     };
 
     it('should register successfully and return agent profile', async () => {
@@ -496,6 +498,25 @@ describe('webex.cc', () => {
       );
     });
 
+    it('clears wellness session context when registration fails after relogin', async () => {
+      const mockError = new Error('Error after silent relogin');
+      webex.cc.$config = {...webex.cc.$config, allowAutomatedRelogin: true};
+      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue({
+        ...mockAgentProfile,
+        webRtcEnabled: false,
+        aiFeature: undefined,
+      } as Profile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: 'agent123'});
+      jest.spyOn(webex.cc as any, 'silentRelogin').mockImplementation(async () => {
+        webex.cc['updateWellnessSession']('partial-session');
+        throw mockError;
+      });
+
+      await expect(webex.cc.register()).rejects.toThrow(mockError);
+
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
     it('should log error if mercury connect fails but cc.register() should not fail', async () => {
       const mockError = new Error('Error while performing mercury connect');
       jest.spyOn(webex.internal.mercury, 'connect').mockRejectedValue(mockError);
@@ -2070,6 +2091,227 @@ describe('webex.cc', () => {
     });
   });
 
+  describe('Agent Wellness Break SDK contracts', () => {
+    const wellbeingCode = {
+      id: 'wellbeing-code',
+      name: 'WellbeingBreak',
+      isSystem: true,
+      isDefault: false,
+    };
+
+    beforeEach(() => {
+      webex.cc.agentConfig = {
+        agentId: 'agent-1',
+        isWellnessBreakEnabled: true,
+      } as Profile;
+      webex.cc['updateWellnessSession']('session-1');
+    });
+
+    it('fetches the system idle code once per registration', async () => {
+      const lookup = jest
+        .spyOn(webex.cc.services.config, 'getWellbeingBreakIdleCode')
+        .mockResolvedValue(wellbeingCode);
+
+      await expect(webex.cc.getWellbeingBreakIdleCode()).resolves.toEqual(wellbeingCode);
+      await expect(webex.cc.getWellbeingBreakIdleCode()).resolves.toEqual(wellbeingCode);
+
+      expect(lookup).toHaveBeenCalledTimes(1);
+      expect(lookup).toHaveBeenCalledWith('mockOrgId');
+    });
+
+    it('does not cache an idle-code lookup that completes after a new registration starts', async () => {
+      let resolveLookup: (idleCode: typeof wellbeingCode) => void = () => undefined;
+      jest
+        .spyOn(webex.cc.services.config, 'getWellbeingBreakIdleCode')
+        .mockImplementation(
+          () =>
+            new Promise((resolve) => {
+              resolveLookup = resolve;
+            })
+        );
+
+      const lookupPromise = webex.cc.getWellbeingBreakIdleCode();
+      const staleLookup = expect(lookupPromise).rejects.toThrow(
+        'WELLNESS_BREAK_REGISTRATION_CHANGED'
+      );
+      jest
+        .spyOn(webex.cc, 'connectWebsocket')
+        .mockRejectedValue(new Error('replacement registration failed'));
+
+      await expect(webex.cc.register()).rejects.toThrow('replacement registration failed');
+      resolveLookup(wellbeingCode);
+
+      await staleLookup;
+      expect(webex.cc['wellbeingBreakIdleCode']).toBeUndefined();
+    });
+
+    it('rejects the system idle-code lookup when wellness is disabled', async () => {
+      webex.cc.agentConfig.isWellnessBreakEnabled = false;
+
+      await expect(webex.cc.getWellbeingBreakIdleCode()).rejects.toThrow(
+        'WELLNESS_BREAK_NOT_ENABLED'
+      );
+      expect(webex.cc.services.config.getWellbeingBreakIdleCode).not.toHaveBeenCalled();
+    });
+
+    it('invalidates the wellness session only for a current-session multi-login close', () => {
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: CC_EVENTS.AGENT_MULTI_LOGIN,
+          data: {
+            type: 'AgentMultiLoginCloseSession',
+            agentSessionId: 'another-session',
+          },
+        })
+      );
+      expect(webex.cc['currentAgentSessionId']).toBe('session-1');
+
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: CC_EVENTS.AGENT_MULTI_LOGIN,
+          data: {
+            type: 'AgentMultiLoginCloseSession',
+            agentSessionId: 'session-1',
+          },
+        })
+      );
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
+    it('emits primary wellness notifications regardless of notification session metadata', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      const payload = {
+        type: 'Wellness_Break_Handler',
+        orgId: 'mockOrgId',
+        trackingId: 'data-notification-tracking',
+        data: {
+          agentId: 'agent-1',
+          orgId: 'mockOrgId',
+          notifType: 'Wellness_Break_Handler',
+          notifDetails: {
+            actionEvent: 'SUGGEST_WELLNESS_BREAK',
+            actionText: 'How about a break?',
+          },
+          data: {
+            orgId: 'mockOrgId',
+            agentSessionId: 'notification-session',
+            interactionId: 'interaction-1',
+          },
+        },
+      };
+
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payload));
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, {
+        agentId: 'agent-1',
+        orgId: 'mockOrgId',
+        agentSessionId: 'notification-session',
+        actionEvent: 'SUGGEST_WELLNESS_BREAK',
+        actionText: 'How about a break?',
+        interactionId: 'interaction-1',
+        trackingId: 'data-notification-tracking',
+      });
+    });
+
+    it.each([
+      ['SUGGEST_WELLNESS_BREAK', 'interactionId'],
+      ['WELLNESS_BREAK_NOT_ALLOWED', 'InteractionId'],
+    ])('normalizes the %s action and either interaction-id spelling', (actionEvent, key) => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: 'Wellness_Break_Handler',
+          orgId: 'mockOrgId',
+          data: {
+            agentId: 'agent-1',
+            orgId: 'mockOrgId',
+            notifType: 'Wellness_Break_Handler',
+            notifDetails: {actionEvent},
+            data: {
+              orgId: 'mockOrgId',
+              agentSessionId: 'session-1',
+              [key]: 'interaction-2',
+            },
+          },
+        })
+      );
+
+      expect(emitSpy).toHaveBeenCalledWith(
+        CC_EVENTS.WELLNESS_BREAK,
+        expect.objectContaining({actionEvent, interactionId: 'interaction-2'})
+      );
+    });
+
+    it('does not promote uncontracted notification text fields', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: 'Wellness_Break_Handler',
+          orgId: 'mockOrgId',
+          trackingId: 'notification-tracking',
+          data: {
+            agentId: 'agent-1',
+            orgId: 'mockOrgId',
+            notifType: 'Wellness_Break_Handler',
+            notifDetails: {
+              actionEvent: 'SUGGEST_WELLNESS_BREAK',
+              actionText2: 'Uncontracted text',
+            },
+            data: {
+              orgId: 'mockOrgId',
+              agentSessionId: 'session-1',
+              InteractionId: 'interaction-qa',
+            },
+          },
+        })
+      );
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, {
+        agentId: 'agent-1',
+        orgId: 'mockOrgId',
+        agentSessionId: 'session-1',
+        actionEvent: 'SUGGEST_WELLNESS_BREAK',
+        interactionId: 'interaction-qa',
+        trackingId: 'notification-tracking',
+      });
+    });
+
+    it('ignores wellness events when the effective flag is disabled or identity is missing', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      const payload = {
+        type: 'Wellness_Break_Handler',
+        orgId: 'mockOrgId',
+        data: {
+          agentId: 'agent-1',
+          orgId: 'mockOrgId',
+          notifType: 'Wellness_Break_Handler',
+          notifDetails: {actionEvent: 'SUGGEST_WELLNESS_BREAK'},
+          data: {orgId: 'mockOrgId', agentSessionId: 'session-1'},
+        },
+      };
+
+      webex.cc.agentConfig.isWellnessBreakEnabled = false;
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payload));
+      webex.cc.agentConfig.isWellnessBreakEnabled = true;
+      const {orgId: omittedOrgId, ...payloadWithoutEnvelopeOrg} = payload;
+      expect(omittedOrgId).toBe('mockOrgId');
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payloadWithoutEnvelopeOrg));
+
+      expect(emitSpy).not.toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, expect.anything());
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_WELLNESS_EVENT_INVALID,
+        {reason: 'wellness_disabled'},
+        ['operational']
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_WELLNESS_EVENT_INVALID,
+        {reason: 'missing_wellness_identity'},
+        ['operational']
+      );
+    });
+
+  });
+
   describe('getBuddyAgents', () => {
     it('should return buddy agents response when successful', async () => {
       const data: BuddyAgents = {state: 'Available', mediaType: 'telephony'};
@@ -2701,6 +2943,32 @@ describe('webex.cc', () => {
       deviceUnregisterSpy = jest.spyOn(webex.internal.device, 'unregister');
     });
 
+    it('invalidates wellness context before deregistration cleanup can fail', async () => {
+      const cleanupError = new Error('cleanup failed');
+      let rejectCleanup: (error: Error) => void = () => undefined;
+      const cleanup = new Promise((resolve, reject) => {
+        rejectCleanup = reject;
+      });
+      webex.cc.agentConfig = {
+        ...webex.cc.agentConfig,
+        isWellnessBreakEnabled: true,
+      };
+      webex.cc['updateWellnessSession']('session-1');
+      jest.spyOn(webex.cc as any, 'teardownWxAppLocalState').mockReturnValue(cleanup);
+
+      const deregistration = webex.cc.deregister();
+      const rejection = expect(deregistration).rejects.toThrow(cleanupError);
+
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+      await expect(webex.cc.apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_SESSION_REQUIRED'
+      );
+
+      rejectCleanup(cleanupError);
+      await rejection;
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
     it('should unregister successfully and clean up all resources when webrtc is enabled', async () => {
       webex.cc.services.rtdWebSocketManager = {
         isSocketClosed: false,

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

@@ -2,7 +2,12 @@ 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, RealTimeAssistanceUserActionId, WebexSDK} from '../../../../src/types';
+import {
+  HTTP_METHODS,
+  RealTimeAssistanceUserActionId,
+  WELLNESS_BREAK_USER_ACTIONS,
+  WebexSDK,
+} from '../../../../src/types';
 
 jest.mock('../../../../src/metrics/MetricsManager');
 jest.mock('../../../../src/logger-proxy');
@@ -11,6 +16,11 @@ describe('ApiAIAssistant', () => {
   let apiAIAssistant: ApiAIAssistant;
   let mockWebex: WebexSDK;
   let mockMetricsManager: jest.Mocked<MetricsManager>;
+  let wellnessContext: {
+    isWellnessBreakEnabled: boolean;
+    agentId?: string;
+    agentSessionId?: string;
+  };
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -43,7 +53,8 @@ describe('ApiAIAssistant', () => {
     } as unknown as jest.Mocked<MetricsManager>;
     (MetricsManager.getInstance as jest.Mock).mockReturnValue(mockMetricsManager);
 
-    apiAIAssistant = new ApiAIAssistant(mockWebex);
+    wellnessContext = {isWellnessBreakEnabled: false};
+    apiAIAssistant = new ApiAIAssistant(mockWebex, () => wellnessContext);
   });
 
   it('should send transcript start event successfully', async () => {
@@ -270,4 +281,125 @@ describe('ApiAIAssistant', () => {
 
     expect(errorMessage).toBe('Error while performing sendRealTimeAssistanceUserAction');
   });
+
+  describe('Agent Wellness Break actions', () => {
+    beforeEach(() => {
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+        agentId: 'test-agent-id',
+        agentSessionId: 'session-1',
+      };
+    });
+
+    it('does not expose wellness context mutation on the public assistant instance', () => {
+      expect(apiAIAssistant).not.toHaveProperty('setWellnessContext');
+    });
+
+    it('sends the exact REQUESTED body and resolves only for HTTP 202', async () => {
+      jest.spyOn(Date, 'now').mockReturnValue(1787640000000);
+      (mockWebex.request as jest.Mock).mockResolvedValue({statusCode: 202});
+
+      await expect(apiAIAssistant.requestWellnessBreak()).resolves.toBeUndefined();
+
+      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: 'WellnessBreakAction',
+          eventDetails: {
+            data: {
+              action: 'REQUESTED',
+              agentSessionId: 'session-1',
+              actionTimeStamp: 1787640000000,
+            },
+          },
+        },
+      });
+    });
+
+    it.each([
+      WELLNESS_BREAK_USER_ACTIONS.ACCEPTED,
+      WELLNESS_BREAK_USER_ACTIONS.REJECTED,
+      WELLNESS_BREAK_USER_ACTIONS.NO_RESPONSE,
+    ] as const)(
+      'sends the %s offer action',
+      async (action) => {
+        (mockWebex.request as jest.Mock).mockResolvedValue({statusCode: 202});
+
+        await apiAIAssistant.respondToWellnessBreak({action});
+
+        expect(
+          (mockWebex.request as jest.Mock).mock.calls[0][0].body.eventDetails.data.action
+        ).toBe(action);
+      }
+    );
+
+    it('rejects disabled or incomplete internal session context before HTTP', async () => {
+      wellnessContext = {
+        isWellnessBreakEnabled: false,
+        agentId: 'test-agent-id',
+        agentSessionId: 'session-1',
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_NOT_ENABLED'
+      );
+
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_ID_REQUIRED'
+      );
+
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+        agentId: 'test-agent-id',
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_SESSION_REQUIRED'
+      );
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+
+    it('rejects a missing organization before HTTP', async () => {
+      (mockWebex.credentials.getOrgId as jest.Mock).mockReturnValue('   ');
+
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_ORG_ID_REQUIRED'
+      );
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+
+    it.each([200, 204, 400, 401, 403, 404, 409, 429, 500])(
+      'rejects the non-202 HTTP status %i',
+      async (statusCode) => {
+        (mockWebex.request as jest.Mock).mockResolvedValue({statusCode});
+
+        await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+          `WELLNESS_BREAK_ACTION_UNEXPECTED_STATUS_${statusCode}`
+        );
+      }
+    );
+
+    it('rejects network failures through the structured error path', async () => {
+      (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Network unavailable'));
+
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'Error while performing requestWellnessBreak'
+      );
+    });
+
+    it('rejects unsupported offer actions before HTTP', async () => {
+      await expect(
+        apiAIAssistant.respondToWellnessBreak({
+          action: 'REQUESTED',
+        } as unknown as Parameters<ApiAIAssistant['respondToWellnessBreak']>[0])
+      ).rejects.toThrow('WELLNESS_BREAK_ACTION_INVALID');
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+  });
 });

package/test/unit/spec/services/config/Util.ts

@@ -82,4 +82,48 @@ describe('parseAgentConfigs collaboration access fields', () => {
     expect(profile.accessEntryPoint).toBe('NONE');
     expect(profile.accessBuddyTeam).toBe('ALL');
   });
+
+  it('enables wellness only when organization config, reminders, and license are present', () => {
+    const profile = parseAgentConfigs({
+      ...baseProfileData,
+      orgSettingsData: {...baseProfileData.orgSettingsData, aiAssistantQuantity: 1},
+      aiFeatureFlags: {
+        data: [
+          {
+            id: 'ai-feature-1',
+            agentWellbeing: {
+              enable: true,
+              wellnessBreakReminders: 'ENABLED',
+            },
+          },
+        ],
+      },
+    });
+
+    expect(profile.isWellnessBreakEnabled).toBe(true);
+  });
+
+  it.each([
+    {quantity: 0, enable: true, reminders: 'ENABLED'},
+    {quantity: 1, enable: false, reminders: 'ENABLED'},
+    {quantity: 1, enable: true, reminders: 'DISABLED'},
+  ] as const)(
+    'disables wellness when an effective gate is missing',
+    ({quantity, enable, reminders}) => {
+      const profile = parseAgentConfigs({
+        ...baseProfileData,
+        orgSettingsData: {...baseProfileData.orgSettingsData, aiAssistantQuantity: quantity},
+        aiFeatureFlags: {
+          data: [
+            {
+              id: 'ai-feature-1',
+              agentWellbeing: {enable, wellnessBreakReminders: reminders},
+            },
+          ],
+        },
+      });
+
+      expect(profile.isWellnessBreakEnabled).toBe(false);
+    }
+  );
 });

package/test/unit/spec/services/config/index.ts

@@ -705,6 +705,74 @@ describe('AgentConfigService', () => {
     });
   });
 
+  describe('getWellbeingBreakIdleCode', () => {
+    it('uses the system-code query and finds the exact code across pages', async () => {
+      (mockWebexRequest.request as jest.Mock)
+        .mockResolvedValueOnce({
+          statusCode: 200,
+          body: {
+            data: [
+              {id: 'other', name: 'Other', active: true, isSystemCode: true, defaultCode: false},
+            ],
+            meta: {totalPages: 2},
+          },
+        })
+        .mockResolvedValueOnce({
+          statusCode: 200,
+          body: {
+            data: [
+              {
+                id: 'wellbeing-code',
+                name: 'WellbeingBreak',
+                active: true,
+                isSystemCode: true,
+                defaultCode: false,
+              },
+            ],
+            meta: {totalPages: 2},
+          },
+        });
+
+      await expect(agentConfigService.getWellbeingBreakIdleCode(mockOrgId)).resolves.toEqual({
+        id: 'wellbeing-code',
+        name: 'WellbeingBreak',
+        isSystem: true,
+        isDefault: false,
+      });
+      expect(mockWebexRequest.request).toHaveBeenNthCalledWith(1, {
+        service: mockWccAPIURL,
+        resource:
+          `organization/${mockOrgId}/v2/auxiliary-code?page=0&pageSize=100` +
+          '&workType=IDLE_CODE&customFilter=isSystemCode==true&desktopProfileFilter=false',
+        method: 'GET',
+      });
+      expect(mockWebexRequest.request).toHaveBeenNthCalledWith(2, {
+        service: mockWccAPIURL,
+        resource:
+          `organization/${mockOrgId}/v2/auxiliary-code?page=1&pageSize=100` +
+          '&workType=IDLE_CODE&customFilter=isSystemCode==true&desktopProfileFilter=false',
+        method: 'GET',
+      });
+    });
+
+    it('rejects when the exact system code is unavailable', async () => {
+      (mockWebexRequest.request as jest.Mock).mockResolvedValue({
+        statusCode: 200,
+        body: {
+          data: [
+            {id: 'inactive', name: 'WellbeingBreak', active: false, isSystemCode: true},
+            {id: 'lookalike', name: 'wellbeingbreak', active: true, isSystemCode: true},
+          ],
+          meta: {totalPages: 1},
+        },
+      });
+
+      await expect(agentConfigService.getWellbeingBreakIdleCode(mockOrgId)).rejects.toThrow(
+        'WELLBEING_BREAK_IDLE_CODE_NOT_FOUND'
+      );
+    });
+  });
+
   describe('getAgentConfig', () => {
     const mockTeamData = [
       {id: 'team1', name: 'Support Team'},