@aslaluroba/help-center 4.0.9 → 4.0.10

package/fesm2022/aslaluroba-help-center.mjs

@@ -2491,7 +2491,7 @@ class ClientAblyService {
     static sessionId = null;
     static messageUnsubscribe = null;
     static connectionTimeout;
-    static async startConnection(sessionId, ablyToken, onMessageReceived, tenantId, getAblyToken) {
+    static async startConnection(sessionId, ablyToken, onMessageReceived, tenantId, getAblyToken, onActionReceived) {
         // Prevent multiple connections
         if (this.isConnected && this.sessionId === sessionId) {
             return;
@@ -2573,7 +2573,7 @@ class ClientAblyService {
                 }, 10000);
             });
             // Subscribe to the session room
-            await this.joinChannel(sessionId, onMessageReceived, tenantId);
+            await this.joinChannel(sessionId, onMessageReceived, tenantId, onActionReceived);
         }
         catch (error) {
             console.error('Error during Ably connection setup:', error);
@@ -2600,7 +2600,7 @@ class ClientAblyService {
             throw error;
         }
     }
-    static async joinChannel(sessionId, onMessageReceived, tenantId) {
+    static async joinChannel(sessionId, onMessageReceived, tenantId, onActionReceived) {
         if (!this.client) {
             throw new Error('Chat client not initialized');
         }
@@ -2618,10 +2618,21 @@ class ClientAblyService {
                         ? messageData
                         : messageData?.content || messageData?.message || '';
                     const senderType = messageData?.senderType || 3; // Assistant
+                    const attachments = messageData?.attachments || messageData?.attachmentIds;
+                    const actionType = messageData?.actionType;
+                    // Handle action type using extensible action handler
+                    // This supports all action types (known and unknown) in a safe, extensible way
+                    if (onActionReceived && actionType !== undefined && actionType !== null) {
+                        // Execute action handler (may be async, but we don't await to avoid blocking message processing)
+                        Promise.resolve(onActionReceived(actionType, messageData)).catch((error) => {
+                            console.error('Error handling action type:', actionType, error);
+                        });
+                    }
+                    // Extract needsAgent flag (for backward compatibility)
+                    // This is separate from action handling to maintain existing behavior
                     const needsAgent = messageData?.needsAgent ||
                         messageData?.actionType == 'needs_agent' ||
                         false;
-                    const attachments = messageData?.attachments || messageData?.attachmentIds;
                     // Pass message as object if it has attachments, otherwise as string for backward compatibility
                     const messageToPass = attachments?.length > 0
                         ? { content: messageContent, attachments }
@@ -2700,6 +2711,112 @@ class ClientAblyService {
     }
 }
 
+/**
+ * Service for managing AI response action handlers in an extensible way.
+ *
+ * This service provides a registry pattern for handling different action types
+ * from realtime AI responses, making it easy to add new actions without
+ * modifying existing code.
+ *
+ * @publicApi
+ */
+class ActionHandlerService {
+    actionHandlers = new Map();
+    defaultHandler;
+    constructor() {
+        // Register default handler for unknown actions
+        this.setDefaultHandler((messageData) => {
+            const actionType = messageData?.actionType || '';
+            if (actionType && actionType !== '') {
+                console.warn(`[ActionHandlerService] Unknown action type received: "${actionType}". ` +
+                    `Message data:`, messageData);
+            }
+        });
+    }
+    /**
+     * Registers a handler for a specific action type
+     *
+     * @param actionType The action type string (e.g., 'needs_agent', 'end_session')
+     * @param handler The handler function to execute when this action is received
+     */
+    registerHandler(actionType, handler) {
+        if (this.actionHandlers.has(actionType)) {
+            console.warn(`[ActionHandlerService] Handler for action type "${actionType}" already exists. ` +
+                `Overwriting with new handler.`);
+        }
+        this.actionHandlers.set(actionType, handler);
+    }
+    /**
+     * Unregisters a handler for a specific action type
+     *
+     * @param actionType The action type to unregister
+     */
+    unregisterHandler(actionType) {
+        this.actionHandlers.delete(actionType);
+    }
+    /**
+     * Sets the default handler for unknown action types
+     *
+     * @param handler The default handler function
+     */
+    setDefaultHandler(handler) {
+        this.defaultHandler = handler;
+    }
+    /**
+     * Handles an action type by executing the registered handler or default handler
+     *
+     * @param actionType The action type to handle
+     * @param messageData The message data containing the action
+     * @returns Promise that resolves when handling is complete
+     */
+    async handleAction(actionType, messageData) {
+        // Handle empty string or null/undefined - do nothing as per requirements
+        if (!actionType || actionType === '') {
+            return;
+        }
+        const handler = this.actionHandlers.get(actionType);
+        if (handler) {
+            try {
+                await handler(messageData);
+            }
+            catch (error) {
+                console.error(`[ActionHandlerService] Error executing handler for action type "${actionType}":`, error);
+            }
+        }
+        else if (this.defaultHandler) {
+            // Use default handler for unknown actions
+            try {
+                await this.defaultHandler(messageData);
+            }
+            catch (error) {
+                console.error(`[ActionHandlerService] Error executing default handler for action type "${actionType}":`, error);
+            }
+        }
+    }
+    /**
+     * Gets all registered action types
+     *
+     * @returns Array of registered action type strings
+     */
+    getRegisteredActions() {
+        return Array.from(this.actionHandlers.keys());
+    }
+    /**
+     * Clears all registered handlers (useful for testing or cleanup)
+     */
+    clearHandlers() {
+        this.actionHandlers.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: ActionHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: ActionHandlerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: ActionHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
 /**
  * Service for managing chat session lifecycle and operations.
  *
@@ -2712,6 +2829,7 @@ class ClientAblyService {
  */
 class ChatSessionService {
     apiService = inject(ApiService);
+    actionHandlerService = inject(ActionHandlerService);
     /**
      * Creates a new chat session with the specified option.
      *
@@ -2741,8 +2859,9 @@ class ChatSessionService {
      * @param option Optional option for token refresh (needed for token renewal)
      * @param helpScreenId Optional help screen ID for token refresh
      * @param currentLang Optional current language for token refresh
+     * @param onActionReceived Optional callback function for handling action types
      */
-    async establishAblyConnection(sessionId, ablyToken, onMessageReceived, tenantId, option, helpScreenId, currentLang) {
+    async establishAblyConnection(sessionId, ablyToken, onMessageReceived, tenantId, option, helpScreenId, currentLang, onActionReceived) {
         // Create token refresh callback if context is provided
         let getAblyToken;
         if (option && helpScreenId && currentLang) {
@@ -2762,7 +2881,11 @@ class ChatSessionService {
                 }
             };
         }
-        await ClientAblyService.startConnection(sessionId, ablyToken, onMessageReceived, tenantId, getAblyToken);
+        // Create action handler callback that uses the ActionHandlerService
+        const actionHandler = onActionReceived || ((actionType, messageData) => {
+            this.actionHandlerService.handleAction(actionType, messageData);
+        });
+        await ClientAblyService.startConnection(sessionId, ablyToken, onMessageReceived, tenantId, getAblyToken, actionHandler);
     }
     /**
      * Sends a message in an active chat session.
@@ -2878,10 +3001,12 @@ class HelpCenterWidgetComponent {
     pendingNewChatOption = signal(null, ...(ngDevMode ? [{ debugName: "pendingNewChatOption" }] : []));
     hasUserSentMessages = signal(false, ...(ngDevMode ? [{ debugName: "hasUserSentMessages" }] : []));
     closedSessionIdForReview = signal(null, ...(ngDevMode ? [{ debugName: "closedSessionIdForReview" }] : []));
+    waitingForSessionEndConfirmation = signal(false, ...(ngDevMode ? [{ debugName: "waitingForSessionEndConfirmation" }] : []));
     apiService = inject(ApiService);
     translationService = inject(TranslationService);
     themeService = inject(ThemeService);
     chatSessionService = inject(ChatSessionService);
+    actionHandlerService = inject(ActionHandlerService);
     fileUploadService = inject(FileUploadService);
     destroyRef = inject(DestroyRef);
     themeEffectRef;
@@ -2914,6 +3039,24 @@ class HelpCenterWidgetComponent {
                 // as it's controlled by the parent component
             }
         });
+        // Register action handlers for extensible action handling
+        this.registerActionHandlers();
+    }
+    /**
+     * Registers action handlers for AI response actions.
+     * This uses the ActionHandlerService for extensible, maintainable action handling.
+     */
+    registerActionHandlers() {
+        // Register handler for 'needs_agent' action
+        this.actionHandlerService.registerHandler('needs_agent', () => {
+            // Trigger "handoff / needs agent" UI flow
+            this.needsAgent.set(true);
+        });
+        // Register handler for 'end_session' action
+        this.actionHandlerService.registerHandler('end_session', () => {
+            // Trigger end session flow
+            this.handleEndSessionReceived();
+        });
     }
     ngOnInit() {
         this.showArrowAnimation.set(this.showArrow());
@@ -2985,7 +3128,11 @@ class HelpCenterWidgetComponent {
                 // Read sessionId fresh after async operation to ensure we have the current value
                 const currentSessionId = this.sessionId();
                 if (currentSessionId) {
-                    await this.chatSessionService.establishAblyConnection(currentSessionId, tokenToUse, this.handleReceiveMessage.bind(this), tenantId, selectedOpt, this.helpScreenId(), this.currentLang());
+                    // Use action handler service for extensible action handling
+                    const actionHandler = async (actionType, messageData) => {
+                        await this.actionHandlerService.handleAction(actionType, messageData);
+                    };
+                    await this.chatSessionService.establishAblyConnection(currentSessionId, tokenToUse, this.handleReceiveMessage.bind(this), tenantId, selectedOpt, this.helpScreenId(), this.currentLang(), actionHandler);
                     this.isAblyConnected.set(true);
                 }
             }
@@ -3103,6 +3250,13 @@ class HelpCenterWidgetComponent {
         const sender = this.getSenderType(senderType);
         const messageContent = typeof message === 'string' ? message : message.content || '';
         const attachmentIds = typeof message === 'string' ? undefined : message.attachments;
+        // Check if we're waiting for session end confirmation
+        // The next message after end_session is the confirmation
+        if (this.waitingForSessionEndConfirmation()) {
+            // This is the confirmation message, proceed with end chat flow
+            this.waitingForSessionEndConfirmation.set(false);
+            this.handleEndSessionConfirmed();
+        }
         this.messages.update((msgs) => [
             ...msgs,
             {
@@ -3302,6 +3456,8 @@ class HelpCenterWidgetComponent {
         this.hasUserSentMessages.set(false);
     }
     async endChatSession() {
+        // Reset waiting flag if connection closes before confirmation
+        this.waitingForSessionEndConfirmation.set(false);
         // Read sessionId fresh to ensure we have the current value before async operations
         const currentSessionId = this.sessionId();
         if (currentSessionId) {
@@ -3324,6 +3480,8 @@ class HelpCenterWidgetComponent {
         this.hasUserSentMessages.set(false);
     }
     async closeSessionOnly() {
+        // Reset waiting flag when closing session
+        this.waitingForSessionEndConfirmation.set(false);
         // Read sessionId fresh to ensure we have the current value before async operations
         const currentSessionId = this.sessionId();
         if (currentSessionId) {
@@ -3389,6 +3547,8 @@ class HelpCenterWidgetComponent {
         this.pendingNewChatOption.set(null);
     }
     async clearCurrentChat() {
+        // Reset waiting flag when clearing chat
+        this.waitingForSessionEndConfirmation.set(false);
         // Read sessionId fresh to ensure we have the current value before async operations
         const currentSessionId = this.sessionId();
         if (currentSessionId) {
@@ -3555,6 +3715,27 @@ class HelpCenterWidgetComponent {
             },
         ]);
     }
+    handleEndSessionReceived() {
+        // Set flag to wait for confirmation message
+        // The next message received will be treated as confirmation
+        this.waitingForSessionEndConfirmation.set(true);
+    }
+    async handleEndSessionConfirmed() {
+        // Only proceed if user has sent messages (to show review)
+        if (!this.hasUserSentMessages()) {
+            // No messages sent, just end the chat directly
+            await this.endChatSession();
+            return;
+        }
+        // Store session ID before closing
+        const currentSessionId = this.sessionId();
+        // Close the chat session on backend only (don't change UI state)
+        await this.closeSessionOnly();
+        // Store the closed session ID for review submission
+        this.closedSessionIdForReview.set(currentSessionId);
+        // Add review message to chat
+        this.addReviewMessageToChat();
+    }
     async handleReviewSubmitFromChat(reviewData) {
         try {
             this.isSubmittingReview.set(true);