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

package/src/services/task/TaskManager.ts

@@ -13,10 +13,12 @@ import {
   WebSocketMessage,
   TaskEventActions,
   EventContext,
+  AISummaryFeatureEnablement,
+  AISummary,
 } from './types';
 import {TASK_MANAGER_FILE} from '../../constants';
 import {METHODS, TRANSCRIPT_EVENT_MAP} from './constants';
-import {CC_EVENTS, WrapupData} from '../config/types';
+import {CC_EVENTS, CC_TASK_EVENTS, WrapupData} from '../config/types';
 import {ConfigFlags, LoginOption, AIAssistantEventType, AIAssistantEventName} from '../../types';
 import LoggerProxy from '../../logger-proxy';
 import {
@@ -77,9 +79,15 @@ export default class TaskManager extends EventEmitter {
   private configFlags?: ConfigFlags;
   private wrapupData: WrapupData;
   private agentId: string;
+  private agentName: string;
   private webRtcEnabled: boolean;
   private answerCallOnWebexService?: AnswerCallOnWebexService;
   private apiAIAssistant?: ApiAIAssistant;
+  private receivingSummaryBuffer = new Map<string, AISummary>();
+
+  // RTD feature frames can arrive before AQM creates the task.
+  private pendingFeatureEnablement = new Map<string, AISummaryFeatureEnablement>();
+
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
@@ -100,7 +108,6 @@ export default class TaskManager extends EventEmitter {
     this.rtdWebSocketManager = rtdWebSocketManager;
     this.taskCollection = {};
     this.webRtcEnabled = false;
-
     this.registerTaskListeners();
     this.registerIncomingCallEvent();
   }
@@ -109,6 +116,56 @@ export default class TaskManager extends EventEmitter {
     try {
       const payload = JSON.parse(event);
 
+      switch (payload?.type) {
+        case CC_TASK_EVENTS.FEATURE_ENABLEMENT: {
+          const enablement: AISummaryFeatureEnablement = payload?.data?.data;
+          if (!enablement?.interactionId) return;
+
+          const task = this.taskCollection[enablement.interactionId];
+          if (task) {
+            this.pendingFeatureEnablement.delete(enablement.interactionId);
+            task.setFeatureEnablement?.(enablement);
+            task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
+          } else {
+            this.pendingFeatureEnablement.set(enablement.interactionId, enablement);
+          }
+
+          return;
+        }
+        case CC_TASK_EVENTS.POST_CALL_SUMMARY:
+        case CC_TASK_EVENTS.MID_CALL_SUMMARY: {
+          if (!payload?.data?.data?.conversationId) return;
+
+          this.apiAIAssistant?.resolveFromRtdEvent(
+            payload.type,
+            payload.data.data.conversationId,
+            payload.data.data
+          );
+
+          return;
+        }
+        case CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT: {
+          if (!payload?.data?.data?.conversationId) return;
+
+          const summary: AISummary = payload.data.data;
+          const {conversationId} = summary;
+          const task = this.taskCollection[conversationId];
+          const taskState = task?.state?.value;
+
+          // Emit only once the task is answered; until then it waits for the answer event.
+          if (task && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
+            this.receivingSummaryBuffer.delete(conversationId);
+            task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, summary);
+          } else {
+            this.receivingSummaryBuffer.set(conversationId, summary);
+          }
+
+          return;
+        }
+        default:
+          break;
+      }
+
       const interactionId = payload?.data?.data?.conversationId;
       if (!interactionId) return;
 
@@ -128,6 +185,8 @@ export default class TaskManager extends EventEmitter {
         case CC_EVENTS.SUGGESTED_RESPONSE:
           task.emit(payload.type, payload.data);
           break;
+        default:
+          break;
       }
     } catch (error) {
       LoggerProxy.error('Failed to parse RTD WebSocket message', {
@@ -145,6 +204,13 @@ export default class TaskManager extends EventEmitter {
     this.configFlags = configFlags;
   }
 
+  public clearAISummaryState(): void {
+    this.apiAIAssistant?.clearAllRtdRequests();
+    Object.values(this.taskCollection).forEach((task) => task.clearFeatureEnablement?.());
+    this.receivingSummaryBuffer.clear();
+    this.pendingFeatureEnablement.clear();
+  }
+
   /**
    * Set wrapup configuration data
    */
@@ -159,6 +225,10 @@ export default class TaskManager extends EventEmitter {
     this.agentId = agentId;
   }
 
+  public setAgentName(agentName: string) {
+    this.agentName = agentName;
+  }
+
   /**
    * Gets the current agent ID
    * @returns {string} The agent ID set for this task manager instance
@@ -723,6 +793,15 @@ export default class TaskManager extends EventEmitter {
         task.sendStateMachineEvent(stateMachineEvent);
       }
 
+      // A receiving summary held while the task rang is emitted right after the answer
+      // event above (AgentContactAssigned / AgentConsulting) has been emitted.
+      const bufferedSummary = this.receivingSummaryBuffer.get(task.data.interactionId);
+      const taskState = task.state?.value;
+      if (bufferedSummary && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
+        this.receivingSummaryBuffer.delete(task.data.interactionId);
+        task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, bufferedSummary);
+      }
+
       // Emit TASK_POST_CALL_ACTIVITY for ParticipantPostCallActivity events so
       // consumers (Widgets) can detect the interaction state change to post_call.
       if (eventContext.eventType === CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY) {
@@ -789,6 +868,7 @@ export default class TaskManager extends EventEmitter {
         // Re-key the task under the new interaction ID and remove the old entry
         delete this.taskCollection[reservationInteractionId];
         this.taskCollection[interactionId] = task;
+        this.pendingFeatureEnablement.delete(reservationInteractionId);
       }
     }
 
@@ -1161,7 +1241,9 @@ export default class TaskManager extends EventEmitter {
       this.configFlags,
       this.wrapupData,
       this.agentId,
-      this.answerCallOnWebexService
+      this.agentName,
+      this.answerCallOnWebexService,
+      this.apiAIAssistant
     );
 
     this.taskCollection[stableInteractionId] = task;
@@ -1272,7 +1354,9 @@ export default class TaskManager extends EventEmitter {
         this.configFlags,
         this.wrapupData,
         this.agentId,
-        this.answerCallOnWebexService
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
       );
       this.setupTaskListeners(task);
       this.taskCollection[payload.interactionId] = task;
@@ -1311,7 +1395,9 @@ export default class TaskManager extends EventEmitter {
       this.configFlags,
       this.wrapupData,
       this.agentId,
-      this.answerCallOnWebexService
+      this.agentName,
+      this.answerCallOnWebexService,
+      this.apiAIAssistant
     );
 
     this.setupTaskListeners(task);
@@ -1352,7 +1438,9 @@ export default class TaskManager extends EventEmitter {
         this.configFlags,
         this.wrapupData,
         this.agentId,
-        this.answerCallOnWebexService
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
       );
       this.setupTaskListeners(task);
       this.taskCollection[payload.interactionId] = task;
@@ -1389,6 +1477,10 @@ export default class TaskManager extends EventEmitter {
       }
     });
     this.taskCollection[taskData.interactionId] = task;
+    const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+    if (enablement) {
+      task.setFeatureEnablement?.(enablement);
+    }
 
     return task;
   }
@@ -1398,31 +1490,46 @@ export default class TaskManager extends EventEmitter {
    * This replaces the previous callback injection pattern
    */
   private setupTaskListeners(task: ITask): void {
-    // Listen for TASK_INCOMING and re-emit so webex.cc can notify consumers
-    task.on(TASK_EVENTS.TASK_INCOMING, (t: ITask) => {
-      LoggerProxy.log(`Task incoming event received`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: t.data?.interactionId,
-      });
-
-      this.emit(TASK_EVENTS.TASK_INCOMING, t);
-    });
+    // Apply flags before publication; retain the frame until consumers can attach listeners.
+    const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+    if (enablement) {
+      task.setFeatureEnablement?.(enablement);
+    }
 
-    task.on(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, (t: ITask) => {
-      LoggerProxy.log(`Campaign preview reservation event received`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: t.data?.interactionId,
-      });
+    [
+      TASK_EVENTS.TASK_INCOMING,
+      TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+      TASK_EVENTS.TASK_HYDRATE,
+      TASK_EVENTS.TASK_ASSIGNED,
+    ].forEach((eventName) => {
+      task.on(eventName, (t: ITask) => {
+        if (
+          eventName === TASK_EVENTS.TASK_INCOMING ||
+          eventName === TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION
+        ) {
+          LoggerProxy.log(
+            eventName === TASK_EVENTS.TASK_INCOMING
+              ? 'Task incoming event received'
+              : 'Campaign preview reservation event received',
+            {
+              module: TASK_MANAGER_FILE,
+              method: METHODS.REGISTER_TASK_LISTENERS,
+              interactionId: t.data?.interactionId,
+            }
+          );
+        }
 
-      this.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, t);
-    });
+        // Assignment is already emitted on the task; the other events publish it to consumers.
+        if (eventName !== TASK_EVENTS.TASK_ASSIGNED) {
+          this.emit(eventName, t);
+        }
 
-    // Listen for TASK_HYDRATE on the task and re-emit on TaskManager
-    task.on(TASK_EVENTS.TASK_HYDRATE, (t: ITask) => {
-      // Task data is already updated by the task itself before emitting
-      this.emit(TASK_EVENTS.TASK_HYDRATE, t);
+        const pendingEnablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+        if (pendingEnablement) {
+          this.pendingFeatureEnablement.delete(task.data.interactionId);
+          task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, pendingEnablement);
+        }
+      });
     });
 
     task.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, (t: ITask) => {
@@ -1444,11 +1551,16 @@ export default class TaskManager extends EventEmitter {
   }
 
   private removeTaskFromCollection(task: ITask) {
+    task.clearFeatureEnablement?.();
     task.disposeWxAppOfferObservability?.();
     if (typeof task.cancelAutoWrapupTimer === 'function') {
       task.cancelAutoWrapupTimer();
     }
     if (task?.data?.interactionId) {
+      this.pendingFeatureEnablement.delete(task.data.interactionId);
+      // An offer that ends unanswered (RONA, declined, consult cancelled) is removed here,
+      // so its held receiving summary is dropped instead of being emitted.
+      this.receivingSummaryBuffer.delete(task.data.interactionId);
       Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
         if (candidate === task) {
           delete this.taskCollection[taskId];
@@ -1507,7 +1619,9 @@ export default class TaskManager extends EventEmitter {
         this.configFlags,
         this.wrapupData,
         this.agentId,
-        this.answerCallOnWebexService
+        this.agentName,
+        this.answerCallOnWebexService,
+        this.apiAIAssistant
       );
       this.taskCollection[payload.interactionId] = task;
 
@@ -1527,6 +1641,11 @@ export default class TaskManager extends EventEmitter {
 
     if (task) {
       this.emit(TASK_EVENTS.TASK_MERGED, task);
+      const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
+      if (enablement) {
+        this.pendingFeatureEnablement.delete(task.data.interactionId);
+        task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
+      }
     }
 
     return {task};

package/src/services/task/TaskUtils.ts

@@ -12,6 +12,19 @@ import {TaskContext} from './state-machine/types';
 import {CC_EVENTS} from '../config/types';
 import {OUTBOUND_TYPE, OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE} from '../../constants';
 
+type AISummaryError = Error & {data?: Record<string, unknown>};
+
+export const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.length > 0;
+
+export const createSummaryError = (errorCode: string): AISummaryError => {
+  const error = new Error(errorCode) as AISummaryError;
+
+  error.data = {errorCode};
+
+  return error;
+};
+
 const CAMPAIGN_PREVIEW_OUTBOUND_TYPES = ['STANDARD_PREVIEW_CAMPAIGN', 'DIRECT_PREVIEW_CAMPAIGN'];
 const CAMPAIGN_PREVIEW_CAMPAIGN_TYPES = ['preview_standard', 'preview_direct'];
 

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

@@ -11,8 +11,8 @@
 | Doc kind | Module spec |
 | Coverage score | Partial (manifest-authoritative); 15/15 required document fields present |
 | Generated from | `module-spec` @ SDLC template library `0.2.1` |
-| generated_by / approved_by / updated_at | Codex generator / developer-approved follow-up review remediation / 2026-07-21 |
-| Validation status | Follow-up validation passed (independent Claude fallback, 2026-07-21); 1 existing test-coverage gap; coverage remains Partial |
+| generated_by / approved_by / updated_at | Codex generator / developer-approved follow-up review remediation / 2026-10-06 |
+| Validation status | AI summary methods, delivery, and cleanup updates pending independent review (2026-10-06); prior follow-up validation passed (independent Claude fallback, 2026-07-21); 1 existing test-coverage gap; coverage remains Partial |
 
 ## Evidence Rules
 Every requirement cites stable source and test file paths. Code/tests are the behavioral referee; routed source text supplies explicit intent and rationale. Missing or contradictory evidence blocks promotion.
@@ -143,6 +143,7 @@ services/task/
 | `task.preview-campaign` | SDK/AQM API | `acceptPreviewContact`, `skipPreviewContact`, `removePreviewContact`, and `PreviewContactPayload`. | Accept, skip, or remove a reserved campaign preview contact; each method returns `Promise<TaskResponse>`. | Additive semver-public methods; removals or signature changes are breaking. | `src/cc.ts`, `src/services/task/dialer.ts`, `src/services/task/types.ts` | `../../../../ai-docs/CONTRACTS.md` |
 | `task.consult-transfer-controls` | SDK task controls | `TaskUIControls.consultTransferDestinations` with ordered `consult` and `transfer` arrays. | Surface default destination availability on every Task without an extra policy method. | Additive semver-public field/types; array order is meaningful and the first item is the default. | `src/services/task/types.ts`, `src/services/task/state-machine/uiControlsComputer.ts` | `../../../../ai-docs/CONTRACTS.md` |
 | `task.conference-participant-drop` | SDK/AQM API | `task.dropConferenceParticipant(payload: DropConferenceParticipantPayload): Promise<TaskResponse>`. | Remove a supported target from a voice conference after correlated routing completion. | Additive semver-public method and payload; removals or signature changes are breaking. | `src/services/task/voice/Voice.ts`, `src/services/task/contact.ts`, `src/services/task/types.ts` | `../../../../ai-docs/CONTRACTS.md` |
+| `task.ai-summary` | SDK/RTD API | Post-call and mid-call summary request/response methods, feature enablement, and receiving-agent summary events. | Provide task-scoped generated summaries without exposing RTD correlation to SDK consumers. | Additive semver-public methods, types, and events; removals or signature changes are breaking. | `src/services/task/Task.ts`, `src/services/task/TaskManager.ts`, `src/services/task/types.ts`, `src/services/ApiAiAssistant.ts` | `../../../../ai-docs/CONTRACTS.md` |
 
 Compatibility notes:
 - Do not remove or reinterpret exported symbols/events without a documented consumer migration.
@@ -151,6 +152,8 @@ Compatibility notes:
 
 - `TaskData`, `TaskId`, `TaskResponse`, `TaskUIControls` (`types.ts`)
 
+- `AISummary`, `AISummaryResponse`, `AISummaryAction`, `AISummaryFeatureEnablement`, and `AISummaryCapabilities` (`types.ts`)
+
 - `PreviewContactPayload` (`types.ts`) with `interactionId` and campaign-name `campaignId`
 
 - `DropConferenceParticipantPayload` (`types.ts`) with a runtime-validated non-empty `participantId`
@@ -191,6 +194,8 @@ Compatibility notes:
 | `task:switchCall`                                                           | Switched between consult and main call           |
 | `task:outdialFailed`                                                        | Outdial operation failed                         |
 | `task:ui-controls-updated`                                                  | UI controls changed due to state transition      |
+| `task:midCallSummaryReceived`                                               | Mid-call summary delivered to a receiving agent  |
+| `task:featureEnablement`                                                    | Per-task AI summary enablement flags received     |
 | `task:cleanup`                                                              | Internal cleanup signal emitted by state machine |
 
 > Full list is defined in `TASK_EVENTS` (`types.ts`).
@@ -200,6 +205,23 @@ Compatibility notes:
 | `REAL_TIME_TRANSCRIPTION` | A realtime transcript payload is received for the task interaction |
 | `SUGGESTED_RESPONSE` | A final AI Assistant suggestion payload is received for the task interaction |
 
+### AI summary APIs
+
+- `requestPostCallSummary(): Promise<AISummary>` requests a post-call summary.
+- `sendPostCallSummaryResponse(response: AISummaryResponse): Promise<void>` reports the agent's post-call summary outcome.
+- `requestMidCallSummary(action: AISummaryAction): Promise<AISummary>` requests a consult or transfer summary.
+- `sendMidCallSummaryResponse(response: AISummaryResponse, action: AISummaryAction): Promise<void>` reports the corresponding mid-call outcome.
+
+Summary requests require both the organization-level generated-summary flag and the task-level feature enablement flag. The dedicated request methods read the current organization flags directly from the existing `ApiAIAssistant.aiFeature` field, populated by ContactCenter from the agent configuration. They check `generatedSummaries.wrapUpSummariesEnabled` or `generatedSummaries.consultTransferSummariesEnabled`; missing flags disable the corresponding request. No separate feature-flags argument or task-local organization configuration is needed. A request resolves only after the event POST succeeds and the matching RTD payload arrives; otherwise it rejects with the applicable disabled, transport, or timeout error. Receiving-agent summaries are delivered separately through `task:midCallSummaryReceived`. Summary content is application data and must not be written to logs or metrics.
+
+Task-level feature flags survive `updateTaskData()`, including interaction ID changes during consults or task re-keying. Flags remain available throughout wrapup for post-call summary requests, and TaskManager clears them when the task is removed after wrapup completion or another terminal lifecycle event. Session cleanup also clears them.
+
+Each dedicated Task summary method owns its event selection, payload construction, metrics, and error handling. The request methods call `ApiAIAssistant.requestAndWaitForRtd()`. Both response methods read `interactionId` from the current task data and use `interaction.mainInteractionId` as `conversationId`, falling back to `interactionId`. They call `ApiAIAssistant.sendEvent()` directly without caching request IDs on the task.
+
+TaskManager reads the receiving task directly from `taskCollection[summary.conversationId]`; the RTD conversation ID is the task's collection key (`task.data.interactionId`). It emits `task:midCallSummaryReceived` immediately when that task exists. Otherwise it stores the latest summary for that ID in an in-memory map without an expiry timer, so an RTD frame can wait for task creation. The common AQM event-processing path replays the stored payload after task creation, updates that register the task under that ID, or merge publication. Replay after creation or merge follows the public task event so consumers can attach listeners. Delivery removes the stored summary, and session cleanup clears all pending summaries.
+
+`clearAISummaryState()` cancels pending summary requests, clears task feature enablement, and empties both pending maps. ContactCenter's `deregister()` removes the RTD message listener synchronously before asynchronous teardown. RTD listener registration and removal control inbound delivery; `setConfigFlags()` only supplies task configuration.
+
 Initiate outbound call.
 
 **Parameters**:
@@ -366,7 +388,7 @@ await task.dropConferenceParticipant({participantId});
 
 ### Complete TASK_EVENTS inventory
 
-The public `TASK_EVENTS` enum contains 49 members; every member is listed below from `src/services/task/types.ts`.
+The public `TASK_EVENTS` enum contains 52 members; every member is listed below from `src/services/task/types.ts`.
 
 | Constant | Event string |
 |---|---|
@@ -380,6 +402,7 @@ The public `TASK_EVENTS` enum contains 49 members; every member is listed below
 | `TASK_CONSULT_QUEUE_CANCELLED` | `task:consultQueueCancelled` |
 | `TASK_CONSULT_QUEUE_FAILED` | `task:consultQueueFailed` |
 | `TASK_UI_CONTROLS_UPDATED` | `task:ui-controls-updated` |
+| `TASK_WXAPP_MUTE_STATE_UPDATED` | `task:wxapp-mute-state-updated` |
 | `TASK_CONSULT_ACCEPTED` | `task:consultAccepted` |
 | `TASK_CONSULTING` | `task:consulting` |
 | `TASK_CONSULT_CREATED` | `task:consultCreated` |
@@ -419,6 +442,8 @@ The public `TASK_EVENTS` enum contains 49 members; every member is listed below
 | `TASK_CAMPAIGN_PREVIEW_SKIP_FAILED` | `task:campaignPreviewSkipFailed` |
 | `TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED` | `task:campaignPreviewRemoveFailed` |
 | `TASK_CAMPAIGN_CONTACT_UPDATED` | `task:campaignContactUpdated` |
+| `TASK_MID_CALL_SUMMARY_RECEIVED` | `task:midCallSummaryReceived` |
+| `TASK_FEATURE_ENABLEMENT` | `task:featureEnablement` |
 
 ## Requires (dependencies)
 - Services contact/dialer AQM factories
@@ -1153,7 +1178,7 @@ sequenceDiagram
 
 **API**
 
-- `createTask(contact, webCallingService, data, configFlags, wrapupData?, agentId?): Task`
+- `createTask(contact, webCallingService, data, configFlags, wrapupData?, agentId?, agentName?): Task`
 
 **Behavior**
 
@@ -1229,7 +1254,7 @@ classDiagram
     }
 
     class TaskFactory {
-      + createTask(contact, webCallingService, data, configFlags, wrapupData, agentId) Task
+      + createTask(contact, webCallingService, data, configFlags, wrapupData, agentId, agentName) Task
     }
 
     Task <|-- Voice

package/src/services/task/constants.ts

@@ -30,6 +30,10 @@ export const CAMPAIGN_PREVIEW_SKIP = '/skip';
 export const CAMPAIGN_PREVIEW_REMOVE = '/remove';
 /** 80-second timeout for accepting preview contact (outbound call setup takes longer than default 20s) */
 export const TIMEOUT_PREVIEW_ACCEPT = 80000;
+/** RTD result deadline; the initiating HTTP acknowledgement uses the 20-second service timeout. */
+export const AI_SUMMARY_DURATION_MS = 15000;
+export const AI_SUMMARY_REQUEST_CANCELLED = 'AI_SUMMARY_REQUEST_CANCELLED' as const;
+
 export const TASK_MANAGER_FILE = 'taskManager';
 export const TASK_FILE = 'task';
 
@@ -93,6 +97,12 @@ export const METHODS = {
   SETUP_AUTO_WRAPUP_TIMER: 'setupAutoWrapupTimer',
   CANCEL_AUTO_WRAPUP_TIMER: 'cancelAutoWrapupTimer',
   REQUEST_REAL_TIME_TRANSCRIPTS: 'requestRealTimeTranscripts',
+  REQUEST_POST_CALL_SUMMARY: 'requestPostCallSummary',
+  SEND_POST_CALL_SUMMARY_RESPONSE: 'sendPostCallSummaryResponse',
+  REQUEST_MID_CALL_SUMMARY: 'requestMidCallSummary',
+  SEND_MID_CALL_SUMMARY_RESPONSE: 'sendMidCallSummaryResponse',
+  HANDLE_AI_SUMMARY_EVENT: 'handleAISummaryEvent',
+  CLEAR_AI_SUMMARY_STATE: 'clearAISummaryState',
 };
 
 export const TRANSCRIPT_EVENT_MAP = {

package/src/services/task/digital/Digital.ts

@@ -1,7 +1,8 @@
 import {CC_FILE, METHODS} from '../../../constants';
 import {getErrorDetails} from '../../core/Utils';
 import {ConsultTransferDestinationConfig, IDigital, TaskResponse, TaskData} from '../types';
-import {WrapupData} from '../../config/types';
+import type {WrapupData} from '../../config/types';
+import type ApiAIAssistant from '../../ApiAiAssistant';
 import Task from '../Task';
 import routingContact from '../contact';
 import LoggerProxy from '../../../logger-proxy';
@@ -14,7 +15,9 @@ export default class Digital extends Task implements IDigital {
     data: TaskData,
     wrapupData?: WrapupData,
     agentId?: string,
-    consultTransferConfig?: ConsultTransferDestinationConfig
+    consultTransferConfig?: ConsultTransferDestinationConfig,
+    agentName?: string,
+    apiAIAssistant?: ApiAIAssistant
   ) {
     super(
       contact,
@@ -26,7 +29,9 @@ export default class Digital extends Task implements IDigital {
         consultTransferConfig,
       },
       wrapupData,
-      agentId
+      agentId,
+      agentName,
+      apiAIAssistant
     );
   }
 

package/src/services/task/types.ts

@@ -716,6 +716,27 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_CAMPAIGN_CONTACT_UPDATED = 'task:campaignContactUpdated',
+
+  /**
+   * Triggered when a mid-call summary is received for the task.
+   */
+  TASK_MID_CALL_SUMMARY_RECEIVED = 'task:midCallSummaryReceived',
+
+  /**
+   * Triggered on the task object when AI feature enablement flags arrive for that task's interaction.
+   * Fires immediately if the frame arrived after the task was registered, or at registration time
+   * if the frame arrived before the task (orphan retention). Consumers should use this event
+   * instead of the cc-level `FEATURE_ENABLEMENT` event so they do not need to maintain an
+   * interactionId → flags map manually.
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, (enablement: AISummaryFeatureEnablement) => {
+   *   const { midCallEnabled, postCallEnabled } = enablement;
+   *   // gate summary UI on these flags
+   * });
+   * ```
+   */
+  TASK_FEATURE_ENABLEMENT = 'task:featureEnablement',
 }
 
 /**
@@ -1669,6 +1690,78 @@ export type ParticipantBooleanKey =
  */
 export type TaskResponse = AgentContact | Error | void;
 
+/** AI-assisted mid-call summary action. @public */
+export type AISummaryAction = 'CONSULT' | 'TRANSFER';
+
+/** Feedback value sent with an AI summary response. @public */
+export type AISummaryFeedback = 'none' | 'thumbs_up' | 'thumbs_down';
+
+/** AI summary response state for post-call and mid-call flows. @public */
+export type AISummaryState =
+  | 'DEFAULT'
+  | 'EXCLUDED'
+  | 'IGNORED'
+  | 'MID_CALL_CANCELLED'
+  | 'NOT_RECEIVED';
+
+/** Structured fields shared by post-call and mid-call summaries. @public */
+export type AISummarySections = {
+  initialContactReason?: string;
+  additionalContactReasons?: string;
+  additionalContext?: string;
+  keyActionsTaken?: string;
+  nextSteps?: string;
+  reasonForTransferOrConsult?: string;
+};
+
+/** RTD payload returned or delivered for an AI summary. @public */
+export type AISummary = {
+  conversationId: string;
+  adaptiveCard?: Record<string, unknown>;
+  adaptiveCardId?: string;
+  editAdaptiveCard?: Record<string, unknown>;
+  editAdaptiveCardId?: string;
+  areTranscriptsAvailable?: boolean;
+  languageCode?: string;
+  resolution?: string;
+  sections?: AISummarySections;
+  suggestedWrapUpCodes?: Array<{name: string; [key: string]: unknown}>;
+  suggestedWrapUpCodesMessage?: string;
+  summaryText?: string;
+  timestamp?: number;
+  [key: string]: unknown;
+};
+
+/** RTD payload describing AI-summary feature enablement for an interaction. @public */
+export type AISummaryFeatureEnablement = {
+  interactionId: string;
+  midCallEnabled?: boolean;
+  postCallEnabled?: boolean;
+  actionTimestamp?: number;
+  [key: string]: unknown;
+};
+
+/** Current AI-summary capabilities for a task. @public */
+export type AISummaryCapabilities = Required<
+  Pick<AISummaryFeatureEnablement, 'midCallEnabled' | 'postCallEnabled'>
+>;
+
+/**
+ * Payload sent when reporting a post-call or mid-call summary result.
+ * Transport timestamps are generated by the SDK when the response is sent.
+ * @public
+ */
+export type AISummaryResponse = {
+  summary: AISummarySections | string;
+  feedback: AISummaryFeedback;
+  state: AISummaryState;
+  numberOfTimesViewed: number;
+  numberOfTimesEdited: number;
+  numberOfTimesCopied: number;
+  summaryReceived?: boolean;
+  wrapUpCode?: string;
+};
+
 /**
  * Request payload for removing a supported participant from an active conference.
  * @public
@@ -1717,6 +1810,12 @@ export interface ITask extends IEventEmitter {
    */
   data: TaskData;
 
+  /**
+   * Current AI-summary capabilities for this task. Both flags are false until
+   * the matching feature-enablement event is received.
+   */
+  readonly aiSummaryCapabilities: Readonly<AISummaryCapabilities>;
+
   /**
    * Map associating tasks with their corresponding call identifiers.
    */
@@ -1804,6 +1903,46 @@ export interface ITask extends IEventEmitter {
    */
   cancelAutoWrapupTimer(): void;
 
+  /**
+   * Applies the AI-summary feature flags received for this task's interaction.
+   * @internal
+   */
+  setFeatureEnablement?(enablement: AISummaryFeatureEnablement): void;
+
+  /**
+   * Clears the task-local AI-summary feature flags on task removal or session cleanup.
+   * @internal
+   */
+  clearFeatureEnablement?(): void;
+
+  /**
+   * Requests an AI-generated post-call summary for this task.
+   * @returns Promise resolving with the matching post-call summary payload.
+   */
+  requestPostCallSummary(): Promise<AISummary>;
+
+  /**
+   * Sends the consumer's post-call summary response.
+   * @param response - Validated post-call response observations and summary state.
+   * @returns Promise resolving when AI Assistant acknowledges the response.
+   */
+  sendPostCallSummaryResponse(response: AISummaryResponse): Promise<void>;
+
+  /**
+   * Requests an AI-generated mid-call summary for a consult or transfer flow.
+   * @param action - The consult or transfer flow requesting the summary.
+   * @returns Promise resolving with the matching mid-call summary payload.
+   */
+  requestMidCallSummary(action: AISummaryAction): Promise<AISummary>;
+
+  /**
+   * Sends the consumer's mid-call summary response for a consult or transfer flow.
+   * @param response - Validated mid-call response observations and summary state.
+   * @param action - The consult or transfer flow responding to the summary.
+   * @returns Promise resolving when AI Assistant acknowledges the response.
+   */
+  sendMidCallSummaryResponse(response: AISummaryResponse, action: AISummaryAction): Promise<void>;
+
   /**
    * Deregisters all web call event listeners.
    * Used when cleaning up task resources.