@webex/contact-center 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/test/unit/spec/logger-proxy.ts

@@ -0,0 +1,70 @@
+import LoggerProxy from '../../../src/logger-proxy';
+
+describe('LoggerProxy', () => {
+  beforeEach(() => {
+    // Reset between tests
+    (LoggerProxy as any).logger = undefined;
+  });
+
+  it('no-ops when logger is not initialized', () => {
+    expect(() => {
+      LoggerProxy.log('msg');
+      LoggerProxy.info('msg');
+      LoggerProxy.warn('msg');
+      LoggerProxy.trace('msg');
+      LoggerProxy.error('msg');
+    }).not.toThrow();
+  });
+
+  it('routes calls to the injected logger with formatted context', () => {
+    const logger = {
+      log: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      trace: jest.fn(),
+      error: jest.fn(),
+    };
+
+    LoggerProxy.initialize(logger as any);
+
+    LoggerProxy.log('hello', {module: 'm', method: 'fn', interactionId: 'i', trackingId: 't'});
+    expect(logger.log).toHaveBeenCalled();
+    expect(String(logger.log.mock.calls[0][0])).toContain('module:m - method:fn');
+    expect(String(logger.log.mock.calls[0][0])).toContain('interactionId:i');
+    expect(String(logger.log.mock.calls[0][0])).toContain('trackingId:t');
+
+    LoggerProxy.info('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.warn('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.trace('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.error('hello', {module: 'm', method: 'fn'});
+    expect(logger.info).toHaveBeenCalled();
+    expect(logger.warn).toHaveBeenCalled();
+    expect(logger.trace).toHaveBeenCalled();
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('handles unserializable data and different error shapes', () => {
+    const logger = {
+      log: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      trace: jest.fn(),
+      error: jest.fn(),
+    };
+    LoggerProxy.initialize(logger as any);
+
+    const circular: any = {};
+    circular.self = circular;
+
+    LoggerProxy.info('msg', {module: 'm', method: 'fn', data: circular, error: 'oops'});
+    expect(String(logger.info.mock.calls[0][0])).toContain('data:[object]');
+    expect(String(logger.info.mock.calls[0][0])).toContain('error:oops');
+
+    const err = new Error('boom');
+    LoggerProxy.error('msg', {module: 'm', method: 'fn', error: err});
+    const errorLine = String(logger.error.mock.calls[0][0]);
+    expect(errorLine).toContain('error:Error:boom');
+    expect(errorLine).toContain('stack:');
+  });
+});
+

package/test/unit/spec/metrics/behavioral-events.ts

@@ -152,6 +152,24 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(
+        getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS)
+      ).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_participant_drop',
+        verb: 'complete',
+      });
+
+      expect(
+        getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_FAILED)
+      ).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_participant_drop',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS)).toEqual({
         product,
         agent: 'user',

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

@@ -99,7 +99,8 @@ describe('AddressBook', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -133,7 +134,8 @@ describe('AddressBook', () => {
         module: 'AddressBook',
         method: 'getEntries',
         data: {
-          resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+          resource:
+            '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
           service: 'wcc-api-gateway',
         },
       });
@@ -155,7 +157,8 @@ describe('AddressBook', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/address-book/custom-book-id/entry?page=1&pageSize=25&filter=name%3D%3D%22John+Doe%22&attributes=id%2Cname%2Cnumber&search=john',
+        resource:
+          '/organization/test-org-id/v2/address-book/custom-book-id/entry?page=1&pageSize=25&filter=name%3D%3D%22John+Doe%22&attributes=id%2Cname%2Cnumber&search=john&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -175,6 +178,31 @@ describe('AddressBook', () => {
       );
     });
 
+    it('should allow callers to override the default backend sorting and bypass the default page cache', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await addressBookAPI.getEntries({
+        page: 0,
+        pageSize: 25,
+        sortBy: 'name',
+        sortOrder: 'desc',
+      });
+      await addressBookAPI.getEntries({
+        page: 0,
+        pageSize: 25,
+        sortBy: 'name',
+        sortOrder: 'desc',
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=25&sort=name%2CDESC',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
     it('should handle API errors and track metrics', async () => {
       (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
 
@@ -182,7 +210,8 @@ describe('AddressBook', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -316,14 +345,16 @@ describe('AddressBook', () => {
       expect(result.meta.page).toBe(1);
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
       expect(LoggerProxy.info).toHaveBeenCalledWith('Making API request to fetch address book entries', {
         module: 'AddressBook',
         method: 'getEntries',
         data: {
-          resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100',
+          resource:
+            '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100&sort=name%2CASC',
           service: 'wcc-api-gateway',
         },
       });

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

@@ -0,0 +1,223 @@
+import {expect} from '@jest/globals';
+import AnswerCallOnWebexService from '../../../../src/services/AnswerCallOnWebexService';
+import {WebexSDK} from '../../../../src/types';
+import LoggerProxy from '../../../../src/logger-proxy';
+
+jest.mock('../../../../src/logger-proxy');
+jest.mock('../../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: () => ({uploadLogs: jest.fn()}),
+  },
+}));
+
+const TELEPHONY_BASE = 'https://api.ciscospark.com';
+const CALLS_URL = `${TELEPHONY_BASE}/telephony/calls`;
+
+function makeMockWebex(overrides: Partial<{_serviceUrls: Record<string, string>}> = {}): WebexSDK {
+  return {
+    request: jest.fn().mockResolvedValue({statusCode: 200, body: {}}),
+    internal: {
+      services: {
+        _serviceUrls: {hydra: TELEPHONY_BASE, ...overrides._serviceUrls},
+        get: jest.fn(),
+      },
+    },
+  } as unknown as WebexSDK;
+}
+
+describe('AnswerCallOnWebexService', () => {
+  let webex: WebexSDK;
+  let service: AnswerCallOnWebexService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    webex = makeMockWebex();
+    service = new AnswerCallOnWebexService(webex);
+  });
+
+  describe('getTelephonyBaseUrl resolution', () => {
+    it('uses hydra URL from _serviceUrls when available', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/answer`})
+      );
+    });
+
+    it('falls back to services.get("hydra") when _serviceUrls.hydra is missing', async () => {
+      const hydraBase = 'https://api.ciscospark.com/v1';
+      const get = jest.fn().mockReturnValue(hydraBase);
+      webex = {
+        request: jest.fn().mockResolvedValue({statusCode: 200, body: {}}),
+        internal: {
+          services: {
+            _serviceUrls: {},
+            get,
+          },
+        },
+      } as unknown as WebexSDK;
+      service = new AnswerCallOnWebexService(webex);
+
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      expect(get).toHaveBeenCalledWith('hydra');
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${hydraBase}/telephony/calls/answer`})
+      );
+    });
+
+    it('throws when hydra URL is unavailable', async () => {
+      webex = {
+        request: jest.fn(),
+        internal: {
+          services: {
+            _serviceUrls: {},
+            get: jest.fn().mockReturnValue(''),
+          },
+        },
+      } as unknown as WebexSDK;
+      service = new AnswerCallOnWebexService(webex);
+
+      await expect(service.answerCall({callId: 'c1', endpointId: 'e1'})).rejects.toBeDefined();
+    });
+  });
+
+  describe('answerCall', () => {
+    it('POST /answer with callId and endpointId', async () => {
+      await service.answerCall({callId: 'call-123', endpointId: 'ep-456'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/answer`,
+        method: 'POST',
+        body: {callId: 'call-123', endpointId: 'ep-456'},
+        addAuthHeader: true,
+      });
+    });
+
+    it('includes lineOwnerId when provided', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({body: {callId: 'c1', endpointId: 'e1', lineOwnerId: 'lo-1'}})
+      );
+    });
+
+    it('omits lineOwnerId when not provided', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      const call = (webex.request as jest.Mock).mock.calls[0][0];
+      expect(call.body).not.toHaveProperty('lineOwnerId');
+    });
+
+    it('rejects and logs on request failure', async () => {
+      const err = {
+        statusCode: 400,
+        details: {
+          trackingId: 'track-wxapp-1',
+          data: {reason: 'TELEPHONY_ERROR'},
+        },
+      };
+      (webex.request as jest.Mock).mockRejectedValue(err);
+
+      await expect(service.answerCall({callId: 'c1', endpointId: 'e1'})).rejects.toMatchObject({
+        isWxAppTelephonyError: true,
+        message: 'TELEPHONY_ERROR',
+        trackingId: 'track-wxapp-1',
+        status: 400,
+      });
+      expect(LoggerProxy.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('rejectCall', () => {
+    it('POST /reject with callId', async () => {
+      await service.rejectCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/reject`,
+        method: 'POST',
+        body: {callId: 'call-123'},
+        addAuthHeader: true,
+      });
+    });
+  });
+
+  describe('muteCall', () => {
+    it('POST /mute with callId', async () => {
+      await service.muteCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/mute`, body: {callId: 'call-123'}})
+      );
+    });
+  });
+
+  describe('unmuteCall', () => {
+    it('POST /unmute with callId', async () => {
+      await service.unmuteCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/unmute`, body: {callId: 'call-123'}})
+      );
+    });
+  });
+
+  describe('transmitDtmf', () => {
+    it('POST /transmitDtmf with callId and dtmf', async () => {
+      await service.transmitDtmf({callId: 'call-123', dtmf: '5'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/transmitDtmf`,
+        method: 'POST',
+        body: {callId: 'call-123', dtmf: '5'},
+        addAuthHeader: true,
+      });
+    });
+
+    it('includes lineOwnerId in DTMF request when provided', async () => {
+      await service.transmitDtmf({callId: 'c1', dtmf: '9', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({body: {callId: 'c1', dtmf: '9', lineOwnerId: 'lo-1'}})
+      );
+    });
+  });
+
+  describe('getCallDetails', () => {
+    it('GET /telephony/calls/{callId}', async () => {
+      (webex.request as jest.Mock).mockResolvedValue({body: {muted: true}});
+
+      const result = await service.getCallDetails({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/call-123`,
+        method: 'GET',
+        addAuthHeader: true,
+      });
+      expect(result).toEqual({muted: true});
+    });
+
+    it('includes lineOwnerId query param when provided', async () => {
+      await service.getCallDetails({callId: 'call-123', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/call-123?lineOwnerId=lo-1`})
+      );
+    });
+
+    it('rejects and logs on request failure', async () => {
+      (webex.request as jest.Mock).mockRejectedValue(new Error('network fail'));
+
+      await expect(service.getCallDetails({callId: 'c1'})).rejects.toBeDefined();
+      expect(LoggerProxy.error).toHaveBeenCalled();
+    });
+
+    it('rejects without error log for expected call-not-found during mute backfill race', async () => {
+      (webex.request as jest.Mock).mockRejectedValue({status: 400, message: 'Call not found'});
+
+      await expect(service.getCallDetails({callId: 'c1'})).rejects.toBeDefined();
+      expect(LoggerProxy.error).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,273 @@
+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';
+
+jest.mock('../../../../src/metrics/MetricsManager');
+jest.mock('../../../../src/logger-proxy');
+
+describe('ApiAIAssistant', () => {
+  let apiAIAssistant: ApiAIAssistant;
+  let mockWebex: WebexSDK;
+  let mockMetricsManager: jest.Mocked<MetricsManager>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(WebexRequest, 'getInstance').mockReturnValue({
+      uploadLogs: jest.fn(),
+    } as any);
+
+    mockWebex = {
+      credentials: {
+        getOrgId: jest.fn().mockReturnValue('test-org-id'),
+      },
+      request: jest.fn(),
+      internal: {
+        services: {
+          get: jest.fn().mockReturnValue('https://api.wxcc-us1.cisco.com'),
+        },
+        newMetrics: {
+          submitBehavioralEvent: jest.fn(),
+          submitOperationalEvent: jest.fn(),
+          submitBusinessEvent: jest.fn(),
+        },
+      },
+      ready: true,
+      once: jest.fn(),
+    } as unknown as WebexSDK;
+
+    mockMetricsManager = {
+      trackEvent: jest.fn(),
+      timeEvent: jest.fn(),
+    } as unknown as jest.Mocked<MetricsManager>;
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue(mockMetricsManager);
+
+    apiAIAssistant = new ApiAIAssistant(mockWebex);
+  });
+
+  it('should send transcript start event successfully', async () => {
+    (mockWebex.request as jest.Mock).mockResolvedValue({body: {ok: true}});
+
+    const result = await apiAIAssistant.sendEvent(
+      'test-agent-id',
+      'interaction-1',
+      'CUSTOM_EVENT',
+      'GET_TRANSCRIPTS',
+      {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});
+  });
+
+  it('should fetch historic transcripts with mapped base URL', async () => {
+    const responseBody = {interactionId: 'interaction-1', data: []};
+    (mockWebex.request as jest.Mock).mockResolvedValue({body: responseBody});
+    apiAIAssistant.setAIFeatureFlags({realtimeTranscripts: {enable: true}} as any);
+
+    const result = await apiAIAssistant.fetchHistoricTranscripts('test-agent-id', 'interaction-1');
+
+    expect(mockWebex.request).toHaveBeenCalledWith({
+      uri: 'https://api-ai-assistant.produs1.ciscoccservice.com/transcripts/list',
+      method: HTTP_METHODS.POST,
+      addAuthHeader: true,
+      body: {
+        agentId: 'test-agent-id',
+        orgId: 'test-org-id',
+        interactionId: 'interaction-1',
+      },
+    });
+    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');
+
+    let failed = false;
+    try {
+      await apiAIAssistant.sendEvent(
+        'test-agent-id',
+        'interaction-1',
+        'CUSTOM_EVENT',
+        'GET_TRANSCRIPTS',
+        {action: 'STOP'}
+      );
+    } catch (_error) {
+      failed = true;
+    }
+
+    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');
+  });
+});