@aakash58/chatbot 1.1.15 → 1.1.17

package/esm2022/lib/app/chat/chat.service.mjs

@@ -0,0 +1,445 @@
+import { Injectable, signal, inject, computed } from '@angular/core';
+import { Subject, lastValueFrom } from 'rxjs';
+import { ChatHistoryService } from './services/chat-history.service';
+// Extracted Services
+import { ChatApiService } from './services/chat-api.service';
+import { ChatAudioService } from './services/chat-audio.service';
+import { SnackbarUtils } from '../../shared/snackbar/snackbar.utils';
+import { DOOHBOT_ADVANCED_CONFIG } from '../../core/models/doohbot-config.model';
+import logger from '../../core/utils/logger.service';
+import { AuthService } from './../../core/auth/auth.service';
+import { ChatUIStateService } from './chat-ui-state.service';
+import { PersonalizationService } from '../personalization/personalization.service';
+import * as i0 from "@angular/core";
+export class ChatService {
+    getFallbackReply() {
+        return "I'm sorry 😔, I didn't understand that.";
+    }
+    getFallbackError() {
+        return 'Something went wrong. Please try again.';
+    }
+    constructor() {
+        // Dependencies
+        this.apiService = inject(ChatApiService);
+        this.authService = inject(AuthService);
+        this.audioService = inject(ChatAudioService);
+        this.config = inject(DOOHBOT_ADVANCED_CONFIG, { optional: true });
+        this.chatHistoryService = inject(ChatHistoryService);
+        this.chatUIStateService = inject(ChatUIStateService);
+        this.personalization = inject(PersonalizationService);
+        this.chatSessions = this.chatHistoryService.sessions;
+        // Public messages signal for current context
+        this.messages = signal([]);
+        /**
+         * Determine if suggestion chips should be shown
+         */
+        this.showSuggestionChips = computed(() => {
+            const msgs = this.messages();
+            if (msgs.length === 0)
+                return false;
+            const lastBotMsg = [...msgs].reverse().find((m) => m.sender === 'assistant');
+            return lastBotMsg?.showSuggestions === true;
+        });
+        // Active session
+        this.activeSession = null;
+        // UI state signals (Keep these here as they are relevant to the Chat UI state)
+        this.isLoadingApi = signal(false);
+        this.apiError = signal(null);
+        this.isBotTyping = signal(false);
+        this.promptMode = signal('markdown');
+        this.isStreaming = signal(true); //! `isStreaming` is set to true by default
+        this.messagesStream = [];
+        this.currentResponse = '';
+        this.cancelSubject = new Subject();
+        logger.log('ChatService: Initialized');
+        // Initialize prompt mode from config if available
+        if (this.config?.promptMode) {
+            this.promptMode.set(this.config.promptMode);
+        }
+    }
+    //! ==================== STATE MANAGEMENT ====================
+    /**
+     * Generate a unique session ID
+     */
+    generateSessionId() {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return `session_${crypto.randomUUID()}`;
+        }
+        return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    }
+    /**
+     * Create a new chat session
+     */
+    createSession(userId) {
+        return {
+            id: this.generateSessionId(),
+            timestamp: new Date(),
+            title: 'New Conversation',
+            messages: [],
+            userId,
+        };
+    }
+    /**
+     * Start a new chat session
+     */
+    startNewSession() {
+        // this.cancelRequest(); //! Cancel any ongoing request before starting new session
+        const userId = this.authService.getUserId();
+        this.isBotTyping.set(false);
+        this.isLoadingApi.set(false);
+        this.activeSession = this.createSession(userId);
+        this.messages.set([]);
+    }
+    /**
+     * Load an existing session
+     */
+    loadSession(session) {
+        logger.log('[ChatService] Loading session:', session.id, 'Messages:', session.messages.length);
+        this.activeSession = session;
+        this.messages.set([...session.messages]);
+        logger.log('[ChatService] Messages signal updated. Current count:', this.messages().length);
+    }
+    /**
+     * Get active session
+     */
+    getActiveSession() {
+        return this.activeSession;
+    }
+    /**
+     * Clear messages for current session and start new one
+     */
+    clearMessages() {
+        this.messages.set([]);
+        this.startNewSession();
+    }
+    /**
+     * Add message to current session
+     */
+    addMessage(message) {
+        const newMessage = { ...message, timestamp: new Date() };
+        // Update current messages signal
+        this.messages.update((msgs) => [...msgs, newMessage]);
+        // Save to active session (Server handles actual storage, UI just adds to local signal for immediate feedback)
+        if (message.sender === 'assistant') {
+            this.audioService.playBotSound();
+        }
+    }
+    /**
+     * Continue a chat session
+     */
+    continueSession(sessionId) {
+        logger.log(`[ChatService] continuing session: ${sessionId}`);
+        this.chatHistoryService.loadSessionMessages(sessionId).subscribe((messages) => {
+            const loadedMessages = messages || [];
+            const sessionFromList = this.chatSessions().find((s) => s.id === sessionId);
+            if (sessionFromList) {
+                sessionFromList.messages = loadedMessages;
+                this.loadSession(sessionFromList);
+            }
+            else {
+                const timestamp = loadedMessages.length > 0
+                    ? loadedMessages[loadedMessages.length - 1].timestamp || new Date()
+                    : new Date();
+                const userId = this.authService.getUserId();
+                const newSession = {
+                    id: sessionId,
+                    timestamp: timestamp,
+                    title: 'Previous Conversation',
+                    messages: loadedMessages,
+                    userId,
+                };
+                this.loadSession(newSession);
+            }
+            this.audioService.unlockAudio();
+            this.chatUIStateService.openChat();
+        });
+    }
+    //! ==================== MESSAGE PROCESSING ====================
+    /**
+     * Process a user message: add it, get bot reply, and add bot reply
+     */
+    async sendMessage(text, maxLength = 1000) {
+        const trimmedText = text.trim();
+        if (!trimmedText) {
+            return;
+        }
+        if (trimmedText.length > maxLength) {
+            SnackbarUtils.error(`Message exceeds maximum length of ${maxLength} characters.`);
+            return;
+        }
+        //! Cancel any ongoing request before starting a new one
+        if (this.isBotTyping()) {
+            this.cancelRequest();
+        }
+        const currentSessionId = this.activeSession?.id;
+        this.addMessage({
+            sender: 'user',
+            text: text,
+            completed: true,
+            isHistory: false,
+            id: Date.now().toString(),
+            timestamp: new Date(),
+        });
+        this.isBotTyping.set(true);
+        try {
+            const response = await this.getBotReply(text);
+            // Check if session has changed while waiting for response
+            if (this.activeSession?.id !== currentSessionId) {
+                logger.log(`[ChatService] Ignoring response for session: ${currentSessionId} as active session is now: ${this.activeSession?.id}`);
+                return;
+            }
+            const isFallback = response === this.getFallbackReply();
+            // Only add completion message if it wasn't handled by streaming (response is not empty string)
+            if (response !== '') {
+                this.addMessage({
+                    sender: 'assistant',
+                    text: response,
+                    completed: true,
+                    isHistory: false,
+                    id: Date.now().toString(),
+                    showSuggestions: false, //! Don't show suggestions for fallback reply
+                });
+            }
+        }
+        finally {
+            // Only reset typing if we are still in the same session, or if we want to be safe (though resetting false is usually harmless)
+            if (this.activeSession?.id === currentSessionId) {
+                this.isBotTyping.set(false);
+            }
+        }
+    }
+    //! ==================== API CALLS ====================
+    async getBotReply(userText) {
+        logger.log('Requesting bot reply for:', userText);
+        try {
+            this.isLoadingApi.set(true);
+            this.apiError.set(null);
+            const request = this.buildChatRequest(userText);
+            //! chat endpoints
+            if (this.isStreaming()) {
+                return await this.stream(request);
+            }
+            else {
+                return await this.ask(request);
+            }
+        }
+        catch (error) {
+            SnackbarUtils.error('An error occurred while getting the bot reply.');
+            return this.getFallbackError();
+        }
+    }
+    /**
+     * Builds a chat request payload with the given user text and optional active session
+     * @param {string} userInput - The text provided by the user
+     * @returns {ChatRequest} - A chat request payload with the user text and optional active session
+     * @memberof ChatService
+     */
+    buildChatRequest(userText) {
+        const instructions = this.personalization.getFormattedInstructions();
+        const finalQuestion = instructions ? `${instructions}\n\n${userText}` : userText;
+        const request = {
+            question: finalQuestion,
+            organization_id: this.authService.getOrganizationId() || '',
+            prompt_mode: this.promptMode(),
+            custom_instructions: instructions,
+        };
+        if (this.activeSession && !this.activeSession.id.startsWith('session_')) {
+            request.response_id = this.activeSession.id;
+            logger.log('>>>> conversation continued:', this.activeSession.id);
+        }
+        else {
+            logger.log('>>>> new conversation started');
+        }
+        return request;
+    }
+    // ! Ask api endpoint
+    async ask(request) {
+        logger.log('>>>>Using Standard Chat Endpoint<<<<');
+        const responseSubject = new Subject();
+        const currentSessionId = this.activeSession?.id;
+        this.streamSubscription = this.apiService.sendMessage(request, true).subscribe({
+            next: (response) => {
+                if (this.activeSession?.id === currentSessionId) {
+                    this.isLoadingApi.set(false);
+                }
+                if (response?.success && response.data) {
+                    if (this.activeSession?.id === currentSessionId) {
+                        this.mapSessionId(response.data.id);
+                    }
+                    responseSubject.next(response.data.content || this.getFallbackError());
+                }
+                else {
+                    responseSubject.next(this.getFallbackError());
+                }
+                responseSubject.complete();
+            },
+            error: (error) => {
+                logger.error('Ask error:', error);
+                if (this.activeSession?.id === currentSessionId) {
+                    this.isLoadingApi.set(false);
+                    this.isBotTyping.set(false);
+                }
+                responseSubject.next(this.getFallbackError());
+                responseSubject.complete();
+            },
+        });
+        // Handle manual cancellation
+        const cancelSub = this.cancelSubject.subscribe(() => {
+            responseSubject.next(''); // Resolve with empty string if cancelled
+            responseSubject.complete();
+        });
+        try {
+            return await lastValueFrom(responseSubject);
+        }
+        finally {
+            cancelSub.unsubscribe();
+        }
+    }
+    // ! Stream api endpoint
+    async stream(request) {
+        logger.log('>>>>Using Stream Chat Endpoint<<<<');
+        this.currentResponse = '';
+        this.isBotTyping.set(true);
+        const assistantMessage = {
+            id: Date.now().toString(),
+            sender: 'assistant',
+            text: '',
+            chunks: [],
+            timestamp: new Date(),
+            completed: false,
+            isHistory: false,
+            showSuggestions: false,
+        };
+        // Add empty bubble after first chunk has been received
+        this.addMessage(assistantMessage);
+        const streamComplete$ = new Subject();
+        let hasStarted = false;
+        // Handle manual cancellation for stream
+        const cancelSub = this.cancelSubject.subscribe(() => {
+            if (!streamComplete$.closed) {
+                streamComplete$.next('');
+                streamComplete$.complete();
+            }
+        });
+        this.streamSubscription = this.apiService.sendMessageStream(request).subscribe({
+            next: (chunk) => {
+                if (!hasStarted) {
+                    hasStarted = true;
+                    this.isBotTyping.set(false);
+                    // replace response_id in message id
+                    this.messages.update((msgs) => msgs.map((m) => m.id === assistantMessage.id
+                        ? {
+                            ...m,
+                            ...{ id: chunk.id },
+                        }
+                        : m));
+                    assistantMessage.id = chunk.id;
+                    // Map the session ID to the backend-generated one
+                    this.mapSessionId(chunk.response_id || chunk.id);
+                }
+                const text = chunk.content ?? '';
+                if (!text)
+                    return;
+                // keep message in sync without regeneration
+                this.messages.update((msgs) => msgs.map((m) => m.id === assistantMessage.id
+                    ? {
+                        ...m,
+                        chunks: [...(m.chunks ?? []), text], // immutable append
+                    }
+                    : m));
+                // const message = this.messages().find((m) => m.id === assistantMessage.id);
+                // logger.log('Appending chunk to assistant message:', message?.chunks);
+            },
+            complete: () => {
+                this.isLoadingApi.set(false);
+                // Mark the chunk stream compelted
+                this.messages.update((msgs) => msgs.map((m) => (m.id === assistantMessage.id ? { ...m, completed: true } : m)));
+                // const message = this.messages().find((m) => m.id === assistantMessage.id);
+                // this.currentResponse += message?.chunks?.join('') ?? '';
+                // logger.log('Appending chunk to assistant message:', message?.text);
+                // logger.log('Appending chunk to assistant message:', message?.chunks);
+                streamComplete$.next(this.currentResponse);
+                streamComplete$.complete();
+            },
+            error: (error) => {
+                logger.error('Chat error:', error);
+                SnackbarUtils.error('An error occurred during reply.');
+                this.isLoadingApi.set(false);
+                this.isBotTyping.set(false);
+                SnackbarUtils.error('An error occurred during reply.');
+                if (!hasStarted)
+                    this.addMessage(assistantMessage);
+                if (!assistantMessage.text)
+                    assistantMessage.text = this.getFallbackError();
+                // mark completed, do NOT rebuild content
+                this.messages.update((msgs) => msgs.map((m) => m.id === assistantMessage.id
+                    ? {
+                        ...m,
+                        completed: true,
+                        isHistory: false,
+                        text: assistantMessage.text,
+                    }
+                    : m));
+                streamComplete$.next('');
+                streamComplete$.complete();
+                // this.finalizeStreamError(assistantMessage, hasStarted, streamComplete$);
+            },
+        });
+        try {
+            await lastValueFrom(streamComplete$);
+        }
+        finally {
+            cancelSub.unsubscribe();
+        }
+        return '';
+    }
+    //! -----------------------------------------
+    cancelRequest() {
+        this.cancelSubject.next();
+        // Reset UI states immediately
+        this.isLoadingApi.set(false);
+        this.isBotTyping.set(false);
+        this.currentResponse = '';
+        if (this.streamSubscription) {
+            logger.log('Cancelling ongoing chat request...');
+            this.streamSubscription.unsubscribe();
+            this.streamSubscription = undefined;
+            // Clean up assistant messages:
+            // Remove if completely empty
+            // Mark as completed if it has content
+            this.messages.update((msgs) => msgs
+                .filter((m) => !(m.sender === 'assistant' &&
+                !m.completed &&
+                !m.text &&
+                (!m.chunks || m.chunks.length === 0)))
+                .map((m) => (m.sender === 'assistant' && !m.completed ? { ...m, completed: true } : m)));
+        }
+    }
+    //! ==================== AUDIO ====================
+    unlockAudio() {
+        this.audioService.unlockAudio();
+    }
+    /**
+     * Map local placeholder session ID to backend-generated ID
+     */
+    mapSessionId(responseId) {
+        if (!responseId || !this.activeSession || !this.activeSession.id.startsWith('session_')) {
+            return;
+        }
+        const oldId = this.activeSession.id;
+        logger.log(`[ChatService] Mapping local session ${oldId} → backend ID ${responseId}`);
+        // Update active session subject
+        this.activeSession.id = responseId;
+        // Trigger history refresh to get the server-generated title
+        this.chatHistoryService.invalidateCache();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/app/chat/chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, inject, computed } from '@angular/core';\r\nimport { Subscription, Subject, lastValueFrom } from 'rxjs';\r\nimport { ChatSession } from './model/chat-session.model';\r\nimport { ChatHistoryService } from './services/chat-history.service';\r\n\r\n// Extracted Services\r\nimport { ChatApiService } from './services/chat-api.service';\r\nimport { ChatAudioService } from './services/chat-audio.service';\r\nimport { SnackbarUtils } from '../../shared/snackbar/snackbar.utils';\r\nimport { ChatApiError } from '../../core/models/api-request.model';\r\nimport { DOOHBOT_ADVANCED_CONFIG } from '../../core/models/doohbot-config.model';\r\nimport { Message } from '../../core/models/message';\r\nimport { PromptMode } from '../../core/types/prompt-mode.type';\r\nimport logger from '../../core/utils/logger.service';\r\nimport { ChatRequest } from './model/chat-request.model';\r\nimport { ChatStreamMessage } from './model/chat-stream-message.model';\r\nimport { AuthService } from './../../core/auth/auth.service';\r\n\r\nimport { ChatUIStateService } from './chat-ui-state.service';\r\nimport { PersonalizationService } from '../personalization/personalization.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ChatService {\r\n  // Dependencies\r\n  private apiService = inject(ChatApiService);\r\n  private authService = inject(AuthService);\r\n  private audioService = inject(ChatAudioService);\r\n  private config = inject(DOOHBOT_ADVANCED_CONFIG, { optional: true });\r\n  private chatHistoryService = inject(ChatHistoryService);\r\n  private chatUIStateService = inject(ChatUIStateService);\r\n  private personalization = inject(PersonalizationService);\r\n  private chatSessions = this.chatHistoryService.sessions;\r\n\r\n  // Public messages signal for current context\r\n  public messages = signal<Message[]>([]);\r\n\r\n  /**\r\n   * Determine if suggestion chips should be shown\r\n   */\r\n  public showSuggestionChips = computed(() => {\r\n    const msgs = this.messages();\r\n    if (msgs.length === 0) return false;\r\n    const lastBotMsg = [...msgs].reverse().find((m) => m.sender === 'assistant');\r\n    return lastBotMsg?.showSuggestions === true;\r\n  });\r\n\r\n  // Active session\r\n  private activeSession: ChatSession | null = null;\r\n\r\n  // UI state signals (Keep these here as they are relevant to the Chat UI state)\r\n  public isLoadingApi = signal<boolean>(false);\r\n  public apiError = signal<ChatApiError | null>(null);\r\n  public isBotTyping = signal<boolean>(false);\r\n  public promptMode = signal<PromptMode>('markdown');\r\n  public isStreaming = signal<boolean>(true); //! `isStreaming` is set to true by default\r\n\r\n  messagesStream: Array<ChatStreamMessage> = [];\r\n  currentResponse = '';\r\n\r\n  private streamSubscription?: Subscription;\r\n  private cancelSubject = new Subject<void>();\r\n\r\n  getFallbackReply(): string {\r\n    return \"I'm sorry 😔, I didn't understand that.\";\r\n  }\r\n\r\n  getFallbackError(): string {\r\n    return 'Something went wrong. Please try again.';\r\n  }\r\n\r\n  constructor() {\r\n    logger.log('ChatService: Initialized');\r\n\r\n    // Initialize prompt mode from config if available\r\n    if (this.config?.promptMode) {\r\n      this.promptMode.set(this.config.promptMode);\r\n    }\r\n  }\r\n\r\n  //! ==================== STATE MANAGEMENT ====================\r\n\r\n  /**\r\n   * Generate a unique session ID\r\n   */\r\n  private generateSessionId(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return `session_${crypto.randomUUID()}`;\r\n    }\r\n    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;\r\n  }\r\n\r\n  /**\r\n   * Create a new chat session\r\n   */\r\n  createSession(userId: string): ChatSession {\r\n    return {\r\n      id: this.generateSessionId(),\r\n      timestamp: new Date(),\r\n      title: 'New Conversation',\r\n      messages: [],\r\n      userId,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Start a new chat session\r\n   */\r\n  public startNewSession(): void {\r\n    // this.cancelRequest(); //! Cancel any ongoing request before starting new session\r\n    const userId = this.authService.getUserId();\r\n\r\n    this.isBotTyping.set(false);\r\n    this.isLoadingApi.set(false);\r\n\r\n    this.activeSession = this.createSession(userId);\r\n    this.messages.set([]);\r\n  }\r\n\r\n  /**\r\n   * Load an existing session\r\n   */\r\n  public loadSession(session: ChatSession): void {\r\n    logger.log('[ChatService] Loading session:', session.id, 'Messages:', session.messages.length);\r\n    this.activeSession = session;\r\n    this.messages.set([...session.messages]);\r\n    logger.log('[ChatService] Messages signal updated. Current count:', this.messages().length);\r\n  }\r\n\r\n  /**\r\n   * Get active session\r\n   */\r\n  public getActiveSession(): ChatSession | null {\r\n    return this.activeSession;\r\n  }\r\n\r\n  /**\r\n   * Clear messages for current session and start new one\r\n   */\r\n  clearMessages(): void {\r\n    this.messages.set([]);\r\n    this.startNewSession();\r\n  }\r\n\r\n  /**\r\n   * Add message to current session\r\n   */\r\n  public addMessage(message: Message): void {\r\n    const newMessage = { ...message, timestamp: new Date() };\r\n\r\n    // Update current messages signal\r\n    this.messages.update((msgs) => [...msgs, newMessage]);\r\n\r\n    // Save to active session (Server handles actual storage, UI just adds to local signal for immediate feedback)\r\n    if (message.sender === 'assistant') {\r\n      this.audioService.playBotSound();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Continue a chat session\r\n   */\r\n  public continueSession(sessionId: string): void {\r\n    logger.log(`[ChatService] continuing session: ${sessionId}`);\r\n    this.chatHistoryService.loadSessionMessages(sessionId).subscribe((messages) => {\r\n      const loadedMessages = messages || [];\r\n      const sessionFromList = this.chatSessions().find((s) => s.id === sessionId);\r\n\r\n      if (sessionFromList) {\r\n        sessionFromList.messages = loadedMessages;\r\n        this.loadSession(sessionFromList);\r\n      } else {\r\n        const timestamp =\r\n          loadedMessages.length > 0\r\n            ? loadedMessages[loadedMessages.length - 1].timestamp || new Date()\r\n            : new Date();\r\n\r\n        const userId = this.authService.getUserId();\r\n\r\n        const newSession: ChatSession = {\r\n          id: sessionId,\r\n          timestamp: timestamp,\r\n          title: 'Previous Conversation',\r\n          messages: loadedMessages,\r\n          userId,\r\n        };\r\n        this.loadSession(newSession);\r\n      }\r\n\r\n      this.audioService.unlockAudio();\r\n      this.chatUIStateService.openChat();\r\n    });\r\n  }\r\n\r\n  //! ==================== MESSAGE PROCESSING ====================\r\n\r\n  /**\r\n   * Process a user message: add it, get bot reply, and add bot reply\r\n   */\r\n  public async sendMessage(text: string, maxLength: number = 1000): Promise<void> {\r\n    const trimmedText = text.trim();\r\n    if (!trimmedText) {\r\n      return;\r\n    }\r\n\r\n    if (trimmedText.length > maxLength) {\r\n      SnackbarUtils.error(`Message exceeds maximum length of ${maxLength} characters.`);\r\n      return;\r\n    }\r\n\r\n    //! Cancel any ongoing request before starting a new one\r\n    if (this.isBotTyping()) {\r\n      this.cancelRequest();\r\n    }\r\n\r\n    const currentSessionId = this.activeSession?.id;\r\n\r\n    this.addMessage({\r\n      sender: 'user',\r\n      text: text,\r\n      completed: true,\r\n      isHistory: false,\r\n      id: Date.now().toString(),\r\n      timestamp: new Date(),\r\n    });\r\n\r\n    this.isBotTyping.set(true);\r\n\r\n    try {\r\n      const response = await this.getBotReply(text);\r\n\r\n      // Check if session has changed while waiting for response\r\n      if (this.activeSession?.id !== currentSessionId) {\r\n        logger.log(\r\n          `[ChatService] Ignoring response for session: ${currentSessionId} as active session is now: ${this.activeSession?.id}`,\r\n        );\r\n        return;\r\n      }\r\n\r\n      const isFallback = response === this.getFallbackReply();\r\n\r\n      // Only add completion message if it wasn't handled by streaming (response is not empty string)\r\n      if (response !== '') {\r\n        this.addMessage({\r\n          sender: 'assistant',\r\n          text: response,\r\n          completed: true,\r\n          isHistory: false,\r\n          id: Date.now().toString(),\r\n          showSuggestions: false, //! Don't show suggestions for fallback reply\r\n        });\r\n      }\r\n    } finally {\r\n      // Only reset typing if we are still in the same session, or if we want to be safe (though resetting false is usually harmless)\r\n      if (this.activeSession?.id === currentSessionId) {\r\n        this.isBotTyping.set(false);\r\n      }\r\n    }\r\n  }\r\n\r\n  //! ==================== API CALLS ====================\r\n\r\n  async getBotReply(userText: string): Promise<string> {\r\n    logger.log('Requesting bot reply for:', userText);\r\n\r\n    try {\r\n      this.isLoadingApi.set(true);\r\n      this.apiError.set(null);\r\n\r\n      const request = this.buildChatRequest(userText);\r\n\r\n      //! chat endpoints\r\n      if (this.isStreaming()) {\r\n        return await this.stream(request);\r\n      } else {\r\n        return await this.ask(request);\r\n      }\r\n    } catch (error) {\r\n      SnackbarUtils.error('An error occurred while getting the bot reply.');\r\n      return this.getFallbackError();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Builds a chat request payload with the given user text and optional active session\r\n   * @param {string} userInput - The text provided by the user\r\n   * @returns {ChatRequest} - A chat request payload with the user text and optional active session\r\n   * @memberof ChatService\r\n   */\r\n\r\n  private buildChatRequest(userText: string): ChatRequest {\r\n    const instructions = this.personalization.getFormattedInstructions();\r\n    const finalQuestion = instructions ? `${instructions}\\n\\n${userText}` : userText;\r\n\r\n    const request: ChatRequest = {\r\n      question: finalQuestion,\r\n      organization_id: this.authService.getOrganizationId() || '',\r\n      prompt_mode: this.promptMode(),\r\n      custom_instructions: instructions,\r\n    };\r\n\r\n    if (this.activeSession && !this.activeSession.id.startsWith('session_')) {\r\n      request.response_id = this.activeSession.id;\r\n      logger.log('>>>> conversation continued:', this.activeSession.id);\r\n    } else {\r\n      logger.log('>>>> new conversation started');\r\n    }\r\n\r\n    return request;\r\n  }\r\n\r\n  // ! Ask api endpoint\r\n  private async ask(request: ChatRequest): Promise<string> {\r\n    logger.log('>>>>Using Standard Chat Endpoint<<<<');\r\n\r\n    const responseSubject = new Subject<string>();\r\n\r\n    const currentSessionId = this.activeSession?.id;\r\n\r\n    this.streamSubscription = this.apiService.sendMessage(request, true).subscribe({\r\n      next: (response) => {\r\n        if (this.activeSession?.id === currentSessionId) {\r\n          this.isLoadingApi.set(false);\r\n        }\r\n        if (response?.success && response.data) {\r\n          if (this.activeSession?.id === currentSessionId) {\r\n            this.mapSessionId(response.data.id);\r\n          }\r\n          responseSubject.next(response.data.content || this.getFallbackError());\r\n        } else {\r\n          responseSubject.next(this.getFallbackError());\r\n        }\r\n        responseSubject.complete();\r\n      },\r\n      error: (error) => {\r\n        logger.error('Ask error:', error);\r\n        if (this.activeSession?.id === currentSessionId) {\r\n          this.isLoadingApi.set(false);\r\n          this.isBotTyping.set(false);\r\n        }\r\n        responseSubject.next(this.getFallbackError());\r\n        responseSubject.complete();\r\n      },\r\n    });\r\n\r\n    // Handle manual cancellation\r\n    const cancelSub = this.cancelSubject.subscribe(() => {\r\n      responseSubject.next(''); // Resolve with empty string if cancelled\r\n      responseSubject.complete();\r\n    });\r\n\r\n    try {\r\n      return await lastValueFrom(responseSubject);\r\n    } finally {\r\n      cancelSub.unsubscribe();\r\n    }\r\n  }\r\n\r\n  // ! Stream api endpoint\r\n  private async stream(request: ChatRequest): Promise<string> {\r\n    logger.log('>>>>Using Stream Chat Endpoint<<<<');\r\n\r\n    this.currentResponse = '';\r\n    this.isBotTyping.set(true);\r\n\r\n    const assistantMessage: Message = {\r\n      id: Date.now().toString(),\r\n      sender: 'assistant',\r\n      text: '',\r\n      chunks: [],\r\n      timestamp: new Date(),\r\n      completed: false,\r\n      isHistory: false,\r\n      showSuggestions: false,\r\n    };\r\n\r\n    // Add empty bubble after first chunk has been received\r\n    this.addMessage(assistantMessage);\r\n\r\n    const streamComplete$ = new Subject<string>();\r\n    let hasStarted = false;\r\n\r\n    // Handle manual cancellation for stream\r\n    const cancelSub = this.cancelSubject.subscribe(() => {\r\n      if (!streamComplete$.closed) {\r\n        streamComplete$.next('');\r\n        streamComplete$.complete();\r\n      }\r\n    });\r\n\r\n    this.streamSubscription = this.apiService.sendMessageStream(request).subscribe({\r\n      next: (chunk) => {\r\n        if (!hasStarted) {\r\n          hasStarted = true;\r\n          this.isBotTyping.set(false);\r\n\r\n          // replace response_id in message id\r\n          this.messages.update((msgs) =>\r\n            msgs.map((m) =>\r\n              m.id === assistantMessage.id\r\n                ? {\r\n                  ...m,\r\n                  ...{ id: chunk.id },\r\n                }\r\n                : m,\r\n            ),\r\n          );\r\n\r\n          assistantMessage.id = chunk.id;\r\n\r\n          // Map the session ID to the backend-generated one\r\n          this.mapSessionId(chunk.response_id || chunk.id);\r\n        }\r\n\r\n        const text = chunk.content ?? '';\r\n        if (!text) return;\r\n\r\n        // keep message in sync without regeneration\r\n        this.messages.update((msgs) =>\r\n          msgs.map((m) =>\r\n            m.id === assistantMessage.id\r\n              ? {\r\n                ...m,\r\n                chunks: [...(m.chunks ?? []), text], // immutable append\r\n              }\r\n              : m,\r\n          ),\r\n        );\r\n\r\n        // const message = this.messages().find((m) => m.id === assistantMessage.id);\r\n        // logger.log('Appending chunk to assistant message:', message?.chunks);\r\n      },\r\n      complete: () => {\r\n        this.isLoadingApi.set(false);\r\n\r\n        // Mark the chunk stream compelted\r\n        this.messages.update((msgs) =>\r\n          msgs.map((m) => (m.id === assistantMessage.id ? { ...m, completed: true } : m)),\r\n        );\r\n\r\n        // const message = this.messages().find((m) => m.id === assistantMessage.id);\r\n        // this.currentResponse += message?.chunks?.join('') ?? '';\r\n\r\n        // logger.log('Appending chunk to assistant message:', message?.text);\r\n        // logger.log('Appending chunk to assistant message:', message?.chunks);\r\n\r\n        streamComplete$.next(this.currentResponse);\r\n        streamComplete$.complete();\r\n      },\r\n      error: (error) => {\r\n        logger.error('Chat error:', error);\r\n        SnackbarUtils.error('An error occurred during reply.');\r\n\r\n        this.isLoadingApi.set(false);\r\n        this.isBotTyping.set(false);\r\n        SnackbarUtils.error('An error occurred during reply.');\r\n\r\n        if (!hasStarted) this.addMessage(assistantMessage);\r\n        if (!assistantMessage.text) assistantMessage.text = this.getFallbackError();\r\n\r\n        // mark completed, do NOT rebuild content\r\n        this.messages.update((msgs) =>\r\n          msgs.map((m) =>\r\n            m.id === assistantMessage.id\r\n              ? {\r\n                ...m,\r\n                completed: true,\r\n                isHistory: false,\r\n                text: assistantMessage.text,\r\n              }\r\n              : m,\r\n          ),\r\n        );\r\n\r\n        streamComplete$.next('');\r\n        streamComplete$.complete();\r\n        // this.finalizeStreamError(assistantMessage, hasStarted, streamComplete$);\r\n      },\r\n    });\r\n\r\n    try {\r\n      await lastValueFrom(streamComplete$);\r\n    } finally {\r\n      cancelSub.unsubscribe();\r\n    }\r\n    return '';\r\n  }\r\n\r\n  //! -----------------------------------------\r\n\r\n  cancelRequest(): void {\r\n    this.cancelSubject.next();\r\n\r\n    // Reset UI states immediately\r\n    this.isLoadingApi.set(false);\r\n    this.isBotTyping.set(false);\r\n    this.currentResponse = '';\r\n\r\n    if (this.streamSubscription) {\r\n      logger.log('Cancelling ongoing chat request...');\r\n      this.streamSubscription.unsubscribe();\r\n      this.streamSubscription = undefined;\r\n\r\n      // Clean up assistant messages:\r\n      // Remove if completely empty\r\n      // Mark as completed if it has content\r\n      this.messages.update((msgs) =>\r\n        msgs\r\n          .filter(\r\n            (m) =>\r\n              !(\r\n                m.sender === 'assistant' &&\r\n                !m.completed &&\r\n                !m.text &&\r\n                (!m.chunks || m.chunks.length === 0)\r\n              ),\r\n          )\r\n          .map((m) => (m.sender === 'assistant' && !m.completed ? { ...m, completed: true } : m)),\r\n      );\r\n    }\r\n  }\r\n\r\n  //! ==================== AUDIO ====================\r\n\r\n  public unlockAudio(): void {\r\n    this.audioService.unlockAudio();\r\n  }\r\n\r\n  /**\r\n   * Map local placeholder session ID to backend-generated ID\r\n   */\r\n  private mapSessionId(responseId?: string): void {\r\n    if (!responseId || !this.activeSession || !this.activeSession.id.startsWith('session_')) {\r\n      return;\r\n    }\r\n\r\n    const oldId = this.activeSession.id;\r\n    logger.log(`[ChatService] Mapping local session ${oldId} → backend ID ${responseId}`);\r\n\r\n    // Update active session subject\r\n    this.activeSession.id = responseId;\r\n\r\n    // Trigger history refresh to get the server-generated title\r\n    this.chatHistoryService.invalidateCache();\r\n  }\r\n}\r\n"]}

package/esm2022/lib/app/chat/components/chat-button/chat-button.component.mjs

@@ -0,0 +1,50 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ChatButtonComponent {
+    constructor() {
+        this.buttonStyle = 'fab';
+        this.isChatOpen = false;
+        this.unreadCount = 0;
+        this.appTitle = 'Chat';
+        this.appLogoUrl = '';
+        this.appTextLogoUrl = '';
+        this.toggle = new EventEmitter();
+    }
+    get isSidebar() {
+        return this.buttonStyle.startsWith('sidebar');
+    }
+    get sidebarPosition() {
+        if (!this.isSidebar)
+            return 'center';
+        if (this.buttonStyle === 'sidebar')
+            return 'center';
+        return this.buttonStyle.split('-')[1];
+    }
+    onToggle() {
+        this.toggle.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: ChatButtonComponent, isStandalone: true, selector: "app-chat-button", inputs: { buttonStyle: "buttonStyle", isChatOpen: "isChatOpen", unreadCount: "unreadCount", appTitle: "appTitle", appLogoUrl: "appLogoUrl", appTextLogoUrl: "appTextLogoUrl" }, outputs: { toggle: "toggle" }, ngImport: i0, template: "<!-- fab -->\r\n@if (buttonStyle === 'fab' && !isChatOpen) {\r\n  <button class=\"chat-fab\" (click)=\"onToggle()\">\r\n    <!-- <mat-icon>{{ chatIcon }}</mat-icon> -->\r\n    <img style=\"width: 30px; height: 30px\" [src]=\"appLogoUrl\" />\r\n    <!-- <div class=\"chat-logo\"></div> -->\r\n    @if (unreadCount > 0) {\r\n      <span class=\"alert-badge\">\r\n        {{ unreadCount > 9 ? '9+' : unreadCount }}\r\n      </span>\r\n    }\r\n  </button>\r\n}\r\n\r\n<!-- sidebar button -->\r\n@if (isSidebar && !isChatOpen) {\r\n  <button class=\"chat-sidebar\" (click)=\"onToggle()\" [ngClass]=\"sidebarPosition\">\r\n    <!-- <h2 style=\"transform: rotate(-90deg); font-size: 16px\">{{ appTitle }}</h2> -->\r\n    <img style=\"transform: rotate(-90deg); width: 100px; height: 45px\" [src]=\"appTextLogoUrl\" />\r\n\r\n    @if (unreadCount > 0) {\r\n      <span class=\"alert-badge\">\r\n        {{ unreadCount > 9 ? '9+' : unreadCount }}\r\n      </span>\r\n    }\r\n  </button>\r\n}\r\n", styles: [".chat-sidebar{position:fixed;right:0;width:40px;height:120px;border-radius:16px 0 0 16px;background:var(--background-color);color:var(--white);border:none;box-shadow:var(--border-shadow-color);display:flex;justify-content:center;align-items:center;cursor:pointer;z-index:1000}.chat-sidebar.disabled{background:transparent;border-radius:0}.chat-sidebar h2{margin:0;font-size:12px;transform:rotate(-90deg);white-space:nowrap}.chat-sidebar .alert-badge{position:absolute;bottom:15px;right:30px;width:18px;height:18px;border-radius:50%;background:var(--red);color:var(--white);font-size:10px;display:flex;align-items:center;justify-content:center}.chat-sidebar.center{top:50%;transform:translateY(-50%)}.chat-sidebar.top{top:calc(50% - 45vh);transform:none}.chat-sidebar.bottom{top:calc(50% + 30vh);transform:none}.chat-fab{position:fixed;bottom:24px;right:24px;width:56px;height:56px;border-radius:50%;background:var(--background-color);color:var(--white);box-shadow:0 6px 16px rgba(var(--black-rgb),.2);border:none;cursor:pointer;z-index:1000;display:flex;align-items:center;justify-content:center}.chat-fab svg,.chat-fab mat-icon{width:24px;height:24px}.chat-fab:hover{transform:scale(1.1)}.alert-badge{position:absolute;top:-4px;right:-4px;background:var(--red);color:var(--white);border-radius:50%;min-width:18px;height:18px;font-size:11px;display:flex;align-items:center;justify-content:center;font-weight:700;line-height:1}.chat-logo{width:45px;height:45px;mask:url(/assets/logo.svg) no-repeat center;-webkit-mask-size:contain;mask-size:contain;background-color:var(--mat-sys-on-primary)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: MatIconModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-chat-button', standalone: true, imports: [CommonModule, MatIconModule], template: "<!-- fab -->\r\n@if (buttonStyle === 'fab' && !isChatOpen) {\r\n  <button class=\"chat-fab\" (click)=\"onToggle()\">\r\n    <!-- <mat-icon>{{ chatIcon }}</mat-icon> -->\r\n    <img style=\"width: 30px; height: 30px\" [src]=\"appLogoUrl\" />\r\n    <!-- <div class=\"chat-logo\"></div> -->\r\n    @if (unreadCount > 0) {\r\n      <span class=\"alert-badge\">\r\n        {{ unreadCount > 9 ? '9+' : unreadCount }}\r\n      </span>\r\n    }\r\n  </button>\r\n}\r\n\r\n<!-- sidebar button -->\r\n@if (isSidebar && !isChatOpen) {\r\n  <button class=\"chat-sidebar\" (click)=\"onToggle()\" [ngClass]=\"sidebarPosition\">\r\n    <!-- <h2 style=\"transform: rotate(-90deg); font-size: 16px\">{{ appTitle }}</h2> -->\r\n    <img style=\"transform: rotate(-90deg); width: 100px; height: 45px\" [src]=\"appTextLogoUrl\" />\r\n\r\n    @if (unreadCount > 0) {\r\n      <span class=\"alert-badge\">\r\n        {{ unreadCount > 9 ? '9+' : unreadCount }}\r\n      </span>\r\n    }\r\n  </button>\r\n}\r\n", styles: [".chat-sidebar{position:fixed;right:0;width:40px;height:120px;border-radius:16px 0 0 16px;background:var(--background-color);color:var(--white);border:none;box-shadow:var(--border-shadow-color);display:flex;justify-content:center;align-items:center;cursor:pointer;z-index:1000}.chat-sidebar.disabled{background:transparent;border-radius:0}.chat-sidebar h2{margin:0;font-size:12px;transform:rotate(-90deg);white-space:nowrap}.chat-sidebar .alert-badge{position:absolute;bottom:15px;right:30px;width:18px;height:18px;border-radius:50%;background:var(--red);color:var(--white);font-size:10px;display:flex;align-items:center;justify-content:center}.chat-sidebar.center{top:50%;transform:translateY(-50%)}.chat-sidebar.top{top:calc(50% - 45vh);transform:none}.chat-sidebar.bottom{top:calc(50% + 30vh);transform:none}.chat-fab{position:fixed;bottom:24px;right:24px;width:56px;height:56px;border-radius:50%;background:var(--background-color);color:var(--white);box-shadow:0 6px 16px rgba(var(--black-rgb),.2);border:none;cursor:pointer;z-index:1000;display:flex;align-items:center;justify-content:center}.chat-fab svg,.chat-fab mat-icon{width:24px;height:24px}.chat-fab:hover{transform:scale(1.1)}.alert-badge{position:absolute;top:-4px;right:-4px;background:var(--red);color:var(--white);border-radius:50%;min-width:18px;height:18px;font-size:11px;display:flex;align-items:center;justify-content:center;font-weight:700;line-height:1}.chat-logo{width:45px;height:45px;mask:url(/assets/logo.svg) no-repeat center;-webkit-mask-size:contain;mask-size:contain;background-color:var(--mat-sys-on-primary)}\n"] }]
+        }], propDecorators: { buttonStyle: [{
+                type: Input
+            }], isChatOpen: [{
+                type: Input
+            }], unreadCount: [{
+                type: Input
+            }], appTitle: [{
+                type: Input
+            }], appLogoUrl: [{
+                type: Input
+            }], appTextLogoUrl: [{
+                type: Input
+            }], toggle: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app/chat/components/chat-footer/chat-footer.component.mjs

@@ -0,0 +1,12 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+export class ChatFooterComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ChatFooterComponent, isStandalone: true, selector: "app-chat-footer", ngImport: i0, template: "<div class=\"terms-conditions\">\r\n    <!-- Terms and conditions relocated to Personalization Hub -->\r\n</div>", styles: [".terms-conditions{padding:10px 15px;text-align:center;font-size:.8rem;background-color:var(--background-color);border-top:1px solid var(--background-color);border-bottom-left-radius:inherit;border-bottom-right-radius:inherit}.terms-conditions a{color:var(--secondary-text-color);text-decoration:none;transition:color .2s ease}.terms-conditions a:hover{color:var(--primary-color);text-decoration:underline}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChatFooterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-chat-footer', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"terms-conditions\">\r\n    <!-- Terms and conditions relocated to Personalization Hub -->\r\n</div>", styles: [".terms-conditions{padding:10px 15px;text-align:center;font-size:.8rem;background-color:var(--background-color);border-top:1px solid var(--background-color);border-bottom-left-radius:inherit;border-bottom-right-radius:inherit}.terms-conditions a{color:var(--secondary-text-color);text-decoration:none;transition:color .2s ease}.terms-conditions a:hover{color:var(--primary-color);text-decoration:underline}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhdC1mb290ZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZG9vaGJvdC9zcmMvbGliL2FwcC9jaGF0L2NvbXBvbmVudHMvY2hhdC1mb290ZXIvY2hhdC1mb290ZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZG9vaGJvdC9zcmMvbGliL2FwcC9jaGF0L2NvbXBvbmVudHMvY2hhdC1mb290ZXIvY2hhdC1mb290ZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBVS9DLE1BQU0sT0FBTyxtQkFBbUI7K0dBQW5CLG1CQUFtQjttR0FBbkIsbUJBQW1CLDJFQ1hoQyxrSEFFTSxnZERJTSxZQUFZOzs0RkFLWCxtQkFBbUI7a0JBUi9CLFNBQVM7K0JBQ0UsaUJBQWlCLGNBQ2YsSUFBSSxXQUNQLENBQUMsWUFBWSxDQUFDLG1CQUdOLHVCQUF1QixDQUFDLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIENoYW5nZURldGVjdGlvblN0cmF0ZWd5IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC1jaGF0LWZvb3RlcicsXHJcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcclxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcclxuICB0ZW1wbGF0ZVVybDogJy4vY2hhdC1mb290ZXIuY29tcG9uZW50Lmh0bWwnLFxyXG4gIHN0eWxlVXJsczogWycuL2NoYXQtZm9vdGVyLmNvbXBvbmVudC5zY3NzJ10sXHJcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDaGF0Rm9vdGVyQ29tcG9uZW50IHt9XHJcbiIsIjxkaXYgY2xhc3M9XCJ0ZXJtcy1jb25kaXRpb25zXCI+XHJcbiAgICA8IS0tIFRlcm1zIGFuZCBjb25kaXRpb25zIHJlbG9jYXRlZCB0byBQZXJzb25hbGl6YXRpb24gSHViIC0tPlxyXG48L2Rpdj4iXX0=