@webex/contact-center 3.12.0-llmrefactor.2 → 3.12.0-llmrefactor.3

package/src/services/core/ai-docs/core-spec.md

@@ -259,6 +259,7 @@ connectionService.on('connectionLost', (details: ConnectionLostDetails) => {
 | CORE-R-004 | ConnectionService must emit transport-state details and retry `initWebSocket({body, resource})`; ContactCenter owns relogin policy. | Separating transport detection from agent recovery prevents Core from mutating package-level session state. | `src/services/core/websocket/connection-service.ts` | `test/unit/spec/services/core/websocket/connection-service.ts` | None; source and test evidence rechecked during the 2026-07-09 remediation; independent document revalidation pending. | PRESENT |
 | CORE-R-005 | The keepalive worker must use the configured 4-second interval and 16-second close-socket timeout; AQM defaults to 20 seconds unless disabled/overridden. | Accurate timing is required for predictable recovery and request failure behavior. | `src/services/core/constants.ts` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | None; source and test evidence rechecked during the 2026-07-09 remediation; independent document revalidation pending. | PRESENT |
 | CORE-R-006 | Treat Core timeout, keepalive, and recovery constants as fixed behavior controls, not rollout flags; Core owns no feature-gate evaluation. | Conflating operational constants with rollout policy could disable transport or correlation paths unexpectedly. | `src/services/core/constants.ts`, `src/services/index.ts` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | None; rollout applicability is explicitly N/A for Core. | PRESENT |
+| CORE-R-007 | When an AQM request sets `redactSensitiveLogs`, routing-failure and timeout logs must omit the request URL, bind key, response, and raw routing payload while preserving settlement and cleanup behavior. | Dynamic request paths and routing messages can contain participant identifiers or phone numbers that must not enter diagnostic logs. | `src/services/core/aqm-reqs.ts`, `src/services/core/types.ts` | `test/unit/spec/services/core/aqm-reqs.ts` | The flag is internal and opt-in; ordinary AQM logging remains backward compatible. | PRESENT |
 
 ## Design Overview
 Core separates four responsibilities:
@@ -293,7 +294,7 @@ const setState = aqmReqs.req((p: {data: Agent.StateChange}) => ({
 await setState({data: stateChangePayload});
 ```
 
-`CLOSE_SOCKET_TIMEOUT` is 16000 ms. `CONNECTIVITY_CHECK_INTERVAL` drives reconnect attempts separately. `TIMEOUT_REQ` is the 20000 ms default AQM timeout; `WEBSOCKET_EVENT_TIMEOUT` is not the active AqmReqs default.
+`CLOSE_SOCKET_TIMEOUT` is 16000 ms. `CONNECTIVITY_CHECK_INTERVAL` drives reconnect attempts separately. `TIMEOUT_REQ` is the 20000 ms default AQM timeout; `WEBSOCKET_EVENT_TIMEOUT` is not the active AqmReqs default. A request configuration may set internal `redactSensitiveLogs: true`; this changes only routing-failure and timeout diagnostics, not correlation, errors, timing, or cleanup.
 
 ## Data Flow
 ```mermaid
@@ -711,11 +712,13 @@ export const generateTaskErrorObject = (
 ## Pitfalls
 - `initWebSocket` requires both `body` and `resource`; omitting `resource` registers against no durable subscription endpoint.
 - AqmReqs installs notification binds before HTTP and never resolves from acknowledgement; duplicate binds, timeout, and cleanup ordering are correctness-critical.
+- Sensitive AQM configurations must use the opt-in redaction flag so dynamic URLs and raw routing messages are not included in timeout/failure logs.
 - Keepalive closure (16 seconds), lost-connection detection (8 seconds), reconnect interval (5 seconds), and recovery timeout (50 seconds) are separate controls and must not be conflated.
 
 ## Module Do's / Don'ts
 - DO keep authentication and service resolution in the host Webex request layer; `WebexRequest.request` is a thin delegating wrapper.
 - DO mask authorization headers in the `AqmReqs` HTTP-error/timeout paths before those details are logged or surfaced.
+- DO enable `redactSensitiveLogs` for AQM requests whose dynamic URL or event payload can contain identity/PII.
 - DO clear success/failure/cancel bind entries together when an AQM request settles.
 - DON'T move silent-relogin policy into ConnectionService; it emits transport state only.
 - DON'T treat timeout constants as feature flags or reuse one timer for another lifecycle purpose.
@@ -747,6 +750,7 @@ Unit tests mirror module paths under `test/unit/spec/services/core`. Preserve po
 | `CORE-R-004` | `test/unit/spec/services/core/websocket/connection-service.ts` | None. |
 | `CORE-R-005` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | Keep timer-value assertions synchronized with constants. |
 | `CORE-R-006` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | Feature-gate absence is verified from construction/source rather than a dedicated negative test. |
+| `CORE-R-007` | `test/unit/spec/services/core/aqm-reqs.ts` | None. |
 
 ## Traceability
 - Repo architecture: `../../../../ai-docs/ARCHITECTURE.md` · Registry: `../../../../ai-docs/SPEC_INDEX.md`

package/src/services/core/aqm-reqs.ts

@@ -117,16 +117,24 @@ export default class AqmReqs {
             clear();
             const notifFail = c.notifFail!;
             if ('errId' in notifFail) {
-              LoggerProxy.log(`Routing request failed: ${JSON.stringify(msg)}`, {
-                module: AQM_REQS_FILE,
-                method: METHODS.CREATE_PROMISE,
-              });
-              const eerr = new Err.Details(notifFail.errId, msg as any);
-              LoggerProxy.log(`Routing request failed: ${eerr}`, {
-                module: AQM_REQS_FILE,
-                method: METHODS.CREATE_PROMISE,
-              });
-              reject(eerr);
+              const error = new Err.Details(notifFail.errId, msg as any);
+
+              if (c.redactSensitiveLogs) {
+                LoggerProxy.log('Routing request failed (sensitive details redacted)', {
+                  module: AQM_REQS_FILE,
+                  method: METHODS.CREATE_PROMISE,
+                });
+              } else {
+                LoggerProxy.log(`Routing request failed: ${JSON.stringify(msg)}`, {
+                  module: AQM_REQS_FILE,
+                  method: METHODS.CREATE_PROMISE,
+                });
+                LoggerProxy.log(`Routing request failed: ${error}`, {
+                  module: AQM_REQS_FILE,
+                  method: METHODS.CREATE_PROMISE,
+                });
+              }
+              reject(error);
             } else {
               reject(notifFail.err(msg as any));
             }
@@ -176,13 +184,20 @@ export default class AqmReqs {
             if (response?.headers) {
               response.headers.Authorization = '*';
             }
-            LoggerProxy.error(
-              `Routing request timeout${keySuccess}${JSON.stringify(response)}${c.url}`,
-              {
+            if (c.redactSensitiveLogs) {
+              LoggerProxy.error('Routing request timeout (sensitive details redacted)', {
                 module: AQM_REQS_FILE,
                 method: METHODS.CREATE_PROMISE,
-              }
-            );
+              });
+            } else {
+              LoggerProxy.error(
+                `Routing request timeout${keySuccess}${JSON.stringify(response)}${c.url}`,
+                {
+                  module: AQM_REQS_FILE,
+                  method: METHODS.CREATE_PROMISE,
+                }
+              );
+            }
             reject(
               new Err.Details('Service.aqm.reqs.Timeout', {
                 key: keySuccess,

package/src/services/core/types.ts

@@ -20,6 +20,8 @@ export type Req<TRes, TErr> = {
   url: string;
   host?: string;
   method?: HTTP_METHODS;
+  /** Suppress request URLs and routing payloads from AQM logs for sensitive operations. */
+  redactSensitiveLogs?: boolean;
   err?:
     | ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>)
     | Err.IdsMessage

package/src/services/task/Task.ts

@@ -11,6 +11,7 @@ import {
   DESTINATION_TYPE,
   TASK_EVENTS,
   TaskUIControls,
+  DropConferenceParticipantPayload,
   ConsultEndPayload,
   ConsultPayload,
   ConsultTransferPayLoad,
@@ -19,8 +20,10 @@ import {
   TASK_CHANNEL_TYPE,
   VOICE_VARIANT,
   CallId,
+  TaskToggleMuteOptions,
+  TaskTransmitDtmfOptions,
 } from './types';
-import {METHODS} from './constants';
+import {ENTRY_POINT_TRANSFER_DESTINATION_TYPE, METHODS} from './constants';
 import {CC_FILE, TASK_FILE} from '../../constants';
 import {getErrorDetails} from '../core/Utils';
 import routingContact from './contact';
@@ -141,6 +144,14 @@ export default abstract class Task extends EventEmitter implements ITask {
     this.unsupportedMethodError('consultConference');
   }
 
+  public async dropConferenceParticipant(
+    // The base task preserves the public signature; Voice provides the implementation.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    payload: DropConferenceParticipantPayload
+  ): Promise<TaskResponse> {
+    this.unsupportedMethodError(METHODS.DROP_CONFERENCE_PARTICIPANT);
+  }
+
   public async exitConference(): Promise<TaskResponse> {
     this.unsupportedMethodError('exitConference');
   }
@@ -153,10 +164,20 @@ export default abstract class Task extends EventEmitter implements ITask {
     this.unsupportedMethodError('switchCall');
   }
 
-  public async toggleMute(): Promise<void> {
+  public async toggleMute(options?: TaskToggleMuteOptions): Promise<void> {
+    if (options) {
+      // parameter intentionally unused
+    }
     this.unsupportedMethodError('toggleMute');
   }
 
+  public async transmitDtmf(options: TaskTransmitDtmfOptions): Promise<void> {
+    if (options) {
+      // parameter intentionally unused
+    }
+    this.unsupportedMethodError('transmitDtmf');
+  }
+
   public unregisterWebCallListeners(): void {
     // Default implementation - child classes can override
     LoggerProxy.log('unregisterWebCallListeners called', {
@@ -268,6 +289,36 @@ export default abstract class Task extends EventEmitter implements ITask {
    *
    * @returns UI control states for all task actions
    */
+  /**
+   * Update wxApp thick-client answer flag at runtime (Voice overrides).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public setEnableWxBetterTogether(_enabled: boolean): void {
+    // no-op for non-voice tasks
+  }
+
+  /**
+   * Apply wxApp mute state from external sync (Voice overrides).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public applyWxAppMuteStateFromSync(_incomingCallId: string, _muted: boolean): void {
+    // no-op for non-voice tasks
+  }
+
+  /**
+   * Hook for post-assign wxApp sync (Voice overrides).
+   */
+  protected onTaskAssigned(): void {
+    // no-op by default
+  }
+
+  /**
+   * Hook for post-hydrate wxApp sync (Voice overrides).
+   */
+  protected onTaskHydrated(): void {
+    // no-op by default
+  }
+
   protected computeUIControls(): TaskUIControls {
     const snapshot = this.stateMachineService?.getSnapshot?.();
 
@@ -277,8 +328,12 @@ export default abstract class Task extends EventEmitter implements ITask {
 
     const currentState = snapshot.value as TaskState;
     const context = snapshot.context as TaskContext;
+    const mergedContext: TaskContext = {
+      ...context,
+      uiControlConfig: {...context.uiControlConfig, ...this.uiControlConfig},
+    };
 
-    const uiControls = computeUIControls(currentState, context, this.data);
+    const uiControls = computeUIControls(currentState, mergedContext, this.data);
 
     return uiControls;
   }
@@ -427,9 +482,16 @@ export default abstract class Task extends EventEmitter implements ITask {
       emitTaskCampaignPreviewRemoveFailed: this.createEmitSelfAction(
         TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED
       ),
-      emitTaskHydrate: this.createEmitSelfAction(TASK_EVENTS.TASK_HYDRATE, {
-        updateTaskData: true,
-      }),
+      emitTaskHydrate: ({event}: TaskActionArgs) => {
+        this.updateTaskFromEvent(event);
+        LoggerProxy.info(`Emitting task event ${TASK_EVENTS.TASK_HYDRATE}`, {
+          module: TASK_FILE,
+          method: 'emitTaskEvent',
+          interactionId: this.data?.interactionId,
+        });
+        this.emit(TASK_EVENTS.TASK_HYDRATE, this);
+        this.onTaskHydrated();
+      },
       emitTaskOfferContact: this.createEmitSelfAction(TASK_EVENTS.TASK_OFFER_CONTACT, {
         updateTaskData: true,
       }),
@@ -437,6 +499,7 @@ export default abstract class Task extends EventEmitter implements ITask {
         this.updateTaskFromEvent(event);
         this.emit(TASK_EVENTS.TASK_ASSIGNED, this);
         this.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this);
+        this.onTaskAssigned();
       },
       emitTaskEnd: this.createEmitSelfAction(TASK_EVENTS.TASK_END, {updateTaskData: true}),
       emitTaskOfferConsult: this.createEmitSelfAction(TASK_EVENTS.TASK_OFFER_CONSULT, {
@@ -672,10 +735,18 @@ export default abstract class Task extends EventEmitter implements ITask {
         METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
       ]);
       let result: TaskResponse;
-      if (transferPayload.destinationType === DESTINATION_TYPE.QUEUE) {
+      const isQueueTransfer = transferPayload.destinationType === DESTINATION_TYPE.QUEUE;
+      const isEntryPointTransfer = transferPayload.destinationType === DESTINATION_TYPE.ENTRYPOINT;
+
+      if (isQueueTransfer || isEntryPointTransfer) {
         result = await this.contact.vteamTransfer({
           interactionId: this.data.interactionId,
-          data: transferPayload,
+          data: {
+            ...transferPayload,
+            destinationType: isEntryPointTransfer
+              ? ENTRY_POINT_TRANSFER_DESTINATION_TYPE
+              : DESTINATION_TYPE.QUEUE,
+          },
         });
       } else {
         result = await this.contact.blindTransfer({

package/src/services/task/TaskFactory.ts

@@ -1,5 +1,6 @@
 import routingContact from './contact';
 import WebCallingService from '../WebCallingService';
+import AnswerCallOnWebexService from '../AnswerCallOnWebexService';
 import Task from './Task';
 import Voice from './voice/Voice';
 import WebRTC from './voice/WebRTC';
@@ -18,15 +19,19 @@ export default class TaskFactory {
     data: TaskData,
     configFlags: ConfigFlags,
     wrapupData?: WrapupData,
-    agentId?: string
+    agentId?: string,
+    answerCallOnWebexService?: AnswerCallOnWebexService
   ): Task {
     const mediaType = data.interaction.mediaType ?? MEDIA_CHANNEL.TELEPHONY;
-    const {isEndTaskEnabled, isEndConsultEnabled} = configFlags;
+    const {isEndTaskEnabled, isEndConsultEnabled, consultTransfer} = configFlags;
     const recordingEnabled = data?.interaction?.callProcessingDetails?.pauseResumeEnabled ?? true;
     const voiceControlOptions = {
       isEndTaskEnabled,
       isEndConsultEnabled,
       isRecordingEnabled: recordingEnabled,
+      enableWxBetterTogether: configFlags.enableWxBetterTogether ?? false,
+      answerCallOnWebexService,
+      consultTransferConfig: consultTransfer,
     };
     switch (mediaType) {
       case MEDIA_CHANNEL.TELEPHONY:
@@ -46,7 +51,7 @@ export default class TaskFactory {
       case MEDIA_CHANNEL.CHAT:
       case MEDIA_CHANNEL.EMAIL:
       case MEDIA_CHANNEL.SOCIAL:
-        return new Digital(contact, data, wrapupData, agentId);
+        return new Digital(contact, data, wrapupData, agentId, consultTransfer);
 
       default:
         throw new Error(`Unknown media type: ${mediaType}`);