@webex/contact-center 3.12.0-llmrefactor.12 → 3.12.0-llmrefactor.14

package/src/services/wxAppDiagnosticLogging.ts

@@ -31,16 +31,54 @@ export function callIdSuffix(callId: string | null | undefined): string | undefi
   return callId.length <= 8 ? callId : callId.slice(-8);
 }
 
-function logWxApp(message: string, method: string, data: WxAppLogData): void {
-  LoggerProxy.info(`${WXAPP_LOG_PREFIX} ${message}`, {
+function formatLogSuffix(data: WxAppLogData, keys?: string[]): string {
+  const entries = keys
+    ? keys.map((key) => [key, data[key]] as const)
+    : Object.entries(data).filter(([key]) => key !== 'feature' && key !== 'event');
+
+  const parts = entries
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}=${String(value)}`);
+
+  return parts.length > 0 ? ` ${parts.join(' ')}` : '';
+}
+
+function logWxApp(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.log(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
+    module: 'wxAppDiagnosticLogging',
+    method,
+    data: {feature: WXAPP_LOG_FEATURE, ...data},
+  });
+}
+
+function logWxAppWarn(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.warn(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
     module: 'wxAppDiagnosticLogging',
     method,
     data: {feature: WXAPP_LOG_FEATURE, ...data},
   });
 }
 
-function logWxAppError(message: string, method: string, data: WxAppLogData): void {
-  LoggerProxy.error(`${WXAPP_LOG_PREFIX} ${message}`, {
+function logWxAppError(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.error(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
     module: 'wxAppDiagnosticLogging',
     method,
     data: {feature: WXAPP_LOG_FEATURE, ...data},
@@ -56,7 +94,7 @@ export function logWxAppSessionReadiness(params: {
   telephonyTaskType: 'Voice' | 'WebRTC' | 'unknown';
   skipReason?: WxAppSessionSkipReason;
 }): void {
-  logWxApp('session readiness', 'logWxAppSessionReadiness', {
+  const data: WxAppLogData = {
     event: 'session_readiness',
     enableWxBetterTogether: params.enableWxBetterTogether,
     loginOption: params.loginOption,
@@ -65,7 +103,16 @@ export function logWxAppSessionReadiness(params: {
     mercurySubscribed: params.mercurySubscribed,
     telephonyTaskType: params.telephonyTaskType,
     skipReason: params.skipReason,
-  });
+  };
+
+  logWxApp('session readiness', 'logWxAppSessionReadiness', data, [
+    'usersubPublished',
+    'mercurySubscribed',
+    'loginOption',
+    'enableWxBetterTogether',
+    'telephonyTaskType',
+    'skipReason',
+  ]);
 }
 
 export function deriveWxAppAcceptReason(params: {
@@ -111,8 +158,10 @@ export function logWxAppOfferDecision(params: {
   acceptReason: WxAppAcceptReason;
   wxAppParticipantDeviceType?: string;
   hasDeviceCallId: boolean;
+  hasDeviceId?: boolean;
+  usersubPublished?: boolean;
 }): void {
-  logWxApp('offer decision', 'logWxAppOfferDecision', {
+  const data: WxAppLogData = {
     event: 'offer_decision',
     interactionId: params.interactionId,
     acceptVisible: params.acceptVisible,
@@ -120,7 +169,51 @@ export function logWxAppOfferDecision(params: {
     acceptReason: params.acceptReason,
     wxAppParticipantDeviceType: params.wxAppParticipantDeviceType,
     hasDeviceCallId: params.hasDeviceCallId,
-  });
+    hasDeviceId: params.hasDeviceId,
+    usersubPublished: params.usersubPublished,
+  };
+
+  logWxApp('offer decision', 'logWxAppOfferDecision', data, [
+    'acceptReason',
+    'hasDeviceCallId',
+    'hasDeviceId',
+    'usersubPublished',
+    'interactionId',
+    'acceptVisible',
+    'acceptEnabled',
+  ]);
+}
+
+export function logWxAppOfferParticipantMismatch(params: {
+  interactionId: string;
+  usersubPublished: boolean;
+  hasDeviceCallId: boolean;
+  hasDeviceId: boolean;
+  participantDeviceType?: string;
+  acceptVisible: boolean;
+  acceptEnabled: boolean;
+  acceptReason: WxAppAcceptReason;
+}): void {
+  const data: WxAppLogData = {
+    event: 'participant_fields_mismatch',
+    interactionId: params.interactionId,
+    usersubPublished: params.usersubPublished,
+    hasDeviceCallId: params.hasDeviceCallId,
+    hasDeviceId: params.hasDeviceId,
+    participantDeviceType: params.participantDeviceType ?? 'missing',
+    acceptVisible: params.acceptVisible,
+    acceptEnabled: params.acceptEnabled,
+    acceptReason: params.acceptReason,
+  };
+
+  logWxAppWarn('participant fields mismatch', 'logWxAppOfferParticipantMismatch', data, [
+    'usersubPublished',
+    'hasDeviceCallId',
+    'hasDeviceId',
+    'acceptReason',
+    'interactionId',
+    'participantDeviceType',
+  ]);
 }
 
 export function logWxAppTelephonyAction(params: {
@@ -142,18 +235,32 @@ export function logWxAppTelephonyAction(params: {
   };
 
   if (params.phase === 'failed') {
-    logWxAppError(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload);
+    logWxAppError(
+      `telephony ${params.action} ${params.phase}`,
+      'logWxAppTelephonyAction',
+      payload,
+      ['interactionId', 'trackingId', 'httpStatus', 'failureReason']
+    );
   } else {
-    logWxApp(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload);
+    logWxApp(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload, [
+      'interactionId',
+      'action',
+      'phase',
+    ]);
   }
 }
 
 export function logWxAppValidationFailure(reason: string, interactionId?: string): void {
-  logWxAppError('validation failed', 'logWxAppValidationFailure', {
-    event: 'validation_failed',
-    reason,
-    interactionId,
-  });
+  logWxAppError(
+    'validation failed',
+    'logWxAppValidationFailure',
+    {
+      event: 'validation_failed',
+      reason,
+      interactionId,
+    },
+    ['reason', 'interactionId']
+  );
 }
 
 export function logWxAppMercuryMuteSync(params: {
@@ -163,12 +270,17 @@ export function logWxAppMercuryMuteSync(params: {
   interactionId?: string;
   dropReason?: string;
 }): void {
-  logWxApp(`mercury mute sync ${params.phase}`, 'logWxAppMercuryMuteSync', {
-    event: 'mercury_mute_sync',
-    phase: params.phase,
-    muted: params.muted,
-    callIdSuffix: params.callIdSuffix,
-    interactionId: params.interactionId,
-    dropReason: params.dropReason,
-  });
+  logWxApp(
+    `mercury mute sync ${params.phase}`,
+    'logWxAppMercuryMuteSync',
+    {
+      event: 'mercury_mute_sync',
+      phase: params.phase,
+      muted: params.muted,
+      callIdSuffix: params.callIdSuffix,
+      interactionId: params.interactionId,
+      dropReason: params.dropReason,
+    },
+    ['phase', 'muted', 'callIdSuffix', 'interactionId', 'dropReason']
+  );
 }

package/src/types.ts

@@ -8,6 +8,7 @@ import * as Agent from './services/agent/types';
 import * as Contact from './services/task/types';
 import {
   AIFeatureFlags,
+  Entity,
   Profile,
   CreateUserPreferenceRequest,
   UpdateUserPreferenceRequest,
@@ -419,6 +420,9 @@ export interface IContactCenter {
    * cc.register().then(profile => { ... });
    */
   register(): Promise<Profile>;
+
+  /** Returns the system-managed WellbeingBreak idle code for the registered session. */
+  getWellbeingBreakIdleCode(): Promise<Entity>;
 }
 
 /**
@@ -614,6 +618,8 @@ export type ConfigFlags = {
   isRecordingEnabled?: boolean;
   /** Whether wxApp thick-client answer controls/APIs are enabled (WXCC-6026) */
   enableWxBetterTogether?: boolean;
+  /** Read-only observability: live usersub answer-calls-on-wxcc state for wxApp offer diagnostics. */
+  getWxAppUsersubPublished?: () => boolean;
 };
 
 /**
@@ -945,6 +951,63 @@ export type RealTimeAssistanceUserActionParams = {
   languageCode?: string;
 };
 
+/**
+ * Wellness notification actions delivered by the Contact Center notification service.
+ * @public
+ */
+export const WELLNESS_BREAK_NOTIFICATION_ACTIONS = {
+  PROVIDE_WELLNESS_BREAK: 'PROVIDE_WELLNESS_BREAK',
+  SUGGEST_WELLNESS_BREAK: 'SUGGEST_WELLNESS_BREAK',
+  WELLNESS_BREAK_NOT_ALLOWED: 'WELLNESS_BREAK_NOT_ALLOWED',
+} as const;
+
+/** Union of supported wellness notification actions. @public */
+export type WellnessBreakNotificationAction = Enum<typeof WELLNESS_BREAK_NOTIFICATION_ACTIONS>;
+
+/**
+ * Agent actions accepted by the wellness action API.
+ * @public
+ */
+export const WELLNESS_BREAK_USER_ACTIONS = {
+  REQUESTED: 'REQUESTED',
+  ACCEPTED: 'ACCEPTED',
+  REJECTED: 'REJECTED',
+  NO_RESPONSE: 'NO_RESPONSE',
+} as const;
+
+/** Union of supported wellness action API values. @public */
+export type WellnessBreakUserAction = Enum<typeof WELLNESS_BREAK_USER_ACTIONS>;
+
+/**
+ * Validated, agent-scoped wellness notification emitted by Contact Center.
+ * @public
+ */
+export interface WellnessBreakEvent {
+  /** Agent identifier */
+  agentId: string;
+  /** Organization identifier */
+  orgId: string;
+  /** Session identifier supplied by the notification; it may differ from the consumer's active session */
+  agentSessionId: string;
+  /** Backend wellness action */
+  actionEvent: WellnessBreakNotificationAction;
+  /** Optional untrusted plain-text message supplied by the backend */
+  actionText?: string;
+  /** Optional normalized interaction diagnostic */
+  interactionId?: string;
+  /** Notification diagnostic only; never an action-request correlation identifier */
+  trackingId?: string;
+}
+
+/**
+ * Parameters for responding to a backend-provided wellness offer.
+ * @public
+ */
+export interface RespondToWellnessBreakParams {
+  /** Agent response; REQUESTED is available only through requestWellnessBreak */
+  action: Exclude<WellnessBreakUserAction, typeof WELLNESS_BREAK_USER_ACTIONS.REQUESTED>;
+}
+
 /**
  * Supported AI Assistant event categories.
  * @public
@@ -994,6 +1057,8 @@ export const AIAssistantEventName = {
   SUGGESTED_RESPONSES_DIGITAL: 'SUGGESTED_RESPONSES_DIGITAL',
   /** User action on a suggested response adaptive card */
   SUGGESTED_RESPONSES_USER_ACTION: 'SUGGESTED_RESPONSES_USER_ACTION',
+  /** Agent Wellness Break request/response action */
+  WELLNESS_BREAK_ACTION: 'WellnessBreakAction',
 } as const;
 
 /**

package/src/webex.js

@@ -9,6 +9,8 @@ import '@webex/internal-plugin-support';
 import './index';
 
 import config from './webex-config';
+import {CC_AGENT_EVENTS} from './services/config/types';
+import {WELLNESS_BREAK_NOTIFICATION_ACTIONS, WELLNESS_BREAK_USER_ACTIONS} from './types';
 
 export * from './index';
 
@@ -30,6 +32,12 @@ const Webex = WebexCore.extend({
   version: PACKAGE_VERSION,
 });
 
+// The standalone UMD bundle exports the Webex constructor as its default value. Attach the
+// public agent-event contract so browser samples can use the same constants as module consumers.
+Webex.CC_AGENT_EVENTS = CC_AGENT_EVENTS;
+Webex.WELLNESS_BREAK_NOTIFICATION_ACTIONS = WELLNESS_BREAK_NOTIFICATION_ACTIONS;
+Webex.WELLNESS_BREAK_USER_ACTIONS = WELLNESS_BREAK_USER_ACTIONS;
+
 /**
  * Initializes a new Webex instance with merged configuration.
  *