@sinequa/assistant 3.9.2 → 3.9.3

package/esm2022/chat/chat.service.mjs

@@ -1,20 +1,22 @@
-import { Injectable, LOCALE_ID, inject } from "@angular/core";
+import { Injectable, inject } from "@angular/core";
 import { TranslocoService } from "@jsverse/transloco";
-import { differenceInDays, differenceInMonths, differenceInYears, endOfYesterday, format, isThisMonth, isThisQuarter, isThisWeek, isThisYear, isToday, isYesterday, parseISO, toDate } from "date-fns";
-import { BehaviorSubject } from "rxjs";
-import { Audit, fetchApp, fetchPrincipal, fetchUserSettings, guid, sha512 } from "@sinequa/atomic";
-import { DialogUpdatesComponent } from "./dialogs/updates.component";
+import { BehaviorSubject, catchError, defer, filter, forkJoin, from, map, switchMap, take, tap, throwError } from "rxjs";
+import { Audit, guid, globalConfig } from "@sinequa/atomic";
 import { AppService } from "./services/app.service";
-import { DialogService } from "./services/dialog.service";
 import { NotificationsService } from "./services/notification.service";
 import { PrincipalService } from "./services/principal.service";
 import { UserSettingsWebService } from "./services/user-settings.service";
-import { chatConfigSchema } from "./types";
-import { getAssistantJsonFromCCApp } from "./utils/assistant-json";
+import { AssistantUtils } from "./utils/utils.service";
+import { SavedChatsService } from "./saved-chats/saved-chats.service";
+import { SignalRConnectionService } from "./services/signalR-connection.service";
+import { AssistantConfigurationService } from "./services/assistant-configuration.service";
+import { AssistantMetadataService } from "./services/assistant-metadata.service";
+import { AssistantTokensTrackingService } from "./services/assistant-tokens-tracking.service";
+import { AssistantWsFramesService } from "./services/assistant-ws-frames.service"; // Added
+import { DebugMessageService } from "./debug-message/debug-message.service";
 import * as i0 from "@angular/core";
 export class ChatService {
     constructor() {
-        this.localID = inject(LOCALE_ID, { optional: true });
         /** Emit true once the initialization of the assistant process is done. */
         this.initProcess$ = new BehaviorSubject(false);
         /** Emit true once the initialization of the assistant config is done. */
@@ -48,16 +50,287 @@ export class ChatService {
         this.userSettingsService = inject(UserSettingsWebService);
         this.notificationsService = inject(NotificationsService);
         this.appService = inject(AppService);
-        this.modalService = inject(DialogService);
         this.principalService = inject(PrincipalService);
+        this.assistantUtils = inject(AssistantUtils);
+        this.savedChatsService = inject(SavedChatsService);
+        this.signalRConnectionService = inject(SignalRConnectionService);
+        this.assistantConfigurationService = inject(AssistantConfigurationService);
+        this.assistantMetadataService = inject(AssistantMetadataService);
+        this.assistantTokensTrackingService = inject(AssistantTokensTrackingService);
+        this.debugMessageService = inject(DebugMessageService);
+        // Inject the AssistantWsFramesService using 'new' to ensure a separate local instance for each ChatService instance
+        this.assistantWsFramesService = new (AssistantWsFramesService);
         this.transloco = inject(TranslocoService);
     }
+    /**
+     * Initialize the assistant process.
+     * It includes building and starting a connection, executing parallel requests for models and functions, and handling errors during the process.
+     * ⚠️ This method MUST be called ONLY if the user is loggedIn and once when the assistant is initialized.
+     *
+     * @returns An Observable<boolean> indicating the success of the initialization process.
+     */
+    init() {
+        // Ensure all logic is executed when subscribed to the observable
+        return defer(() => {
+            this._initAssistantConfigurationService();
+            return from(this.initChatConfig());
+        }).pipe(
+        // Wait for the configuration to be initialized
+        switchMap(() => this.initConfig$.pipe(filter(Boolean), take(1))), tap(() => {
+            this.getWSRequestsUrl();
+            this.getRESTRequestsUrl();
+            this._initAssistantMetadataService();
+            this._initAssistantTokensTrackingService();
+            this._initSavedChatsService();
+            this._initDebugMessageService();
+            this._initSignalRConnectionService();
+        }), 
+        // Build and start the SignalR connection
+        switchMap(() => this.buildConnection()), tap(() => {
+            // Initialize AssistantWsFramesService here, now that 'this.connection' is set
+            this._initAssistantWsFramesService();
+            this.initMessageHandlers();
+        }), 
+        // Start the connection
+        switchMap(() => this.startConnection()), 
+        // Fetch metadata in parallel
+        switchMap(() => forkJoin([
+            this.listModels(),
+            this.listFunctions()
+        ])), 
+        // Map the results of parallel requests to a boolean indicating success
+        map(([models, functions]) => {
+            const result = !!models && !!functions;
+            this.initProcess$.next(result);
+            return result;
+        }), 
+        // Any errors during the process are caught, logged, and re-thrown to propagate the error further
+        catchError((error) => {
+            console.error('Error occurred:', error);
+            return throwError(() => error);
+        }), take(1));
+    }
+    /**
+     * Define the endpoint to use for the websocket requests
+     * It can be overridden by the app config
+     */
+    getWSRequestsUrl() {
+        this.assistantConfigurationService.getWSRequestsUrl();
+    }
+    /**
+     * Define the endpoint to use for the http requests
+     * It can be overridden by the app config
+     */
+    getRESTRequestsUrl() {
+        this.assistantConfigurationService.getRESTRequestsUrl();
+    }
+    /**
+     * Initializes the SavedChatsService with the necessary configuration.
+     *
+     * This method sets up the `SavedChatsService` by providing it with a configuration object
+     * (`SavedChatsOperationConfig`) that includes various callbacks and properties required
+     * for its operation. The initialization will only proceed if both `assistantConfig$` and
+     * `REST_REQUEST_URL` are available.
+     *
+     * The configuration object includes:
+     * - Application name retrieval.
+     * - Instance ID retrieval.
+     * - REST API URL retrieval.
+     * - Debug flag retrieval.
+     * - Chat ID for new saves.
+     * - Saved chats enablement check.
+     * - Methods for setting a saved chat ID, updating the saved chats list, and generating audit events.
+     *
+     * If the required dependencies are not ready, an error is logged to the console.
+     *
+     * @private
+     */
+    _initSavedChatsService() {
+        if (this.assistantConfig$.value && this.REST_REQUEST_URL) {
+            const savedChatsOpConfig = {
+                getAppName: () => this.appService.appName,
+                getInstanceId: () => this.chatInstanceId,
+                getRestUrl: () => this.REST_REQUEST_URL,
+                getDebugFlag: () => this.assistantConfig$.value.defaultValues.debug,
+                isSavedChatsEnabled: () => !!this.assistantConfig$.value?.savedChatSettings.enabled,
+                setSavedChatsErrorStatus: (hasError) => this.savedChatsError$.next(hasError),
+                updateSavedChatsList: (chats) => this.savedChats$.next(chats),
+                generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),
+            };
+            this.savedChatsService.init(savedChatsOpConfig);
+        }
+        else {
+            // This case should ideally not happen if init order is correct
+            console.error("Cannot initialize SavedChatsService: assistantConfig or REST_REQUEST_URL not ready.");
+        }
+    }
+    /**
+     * Initializes the SignalR connection service with the necessary configuration.
+     *
+     * This method ensures that the SignalR connection service is properly set up
+     * by providing it with the required configuration values, such as the WebSocket
+     * request URL and assistant configuration. It also manages the SignalR hub connection
+     * instance.
+     *
+     * Preconditions:
+     * - `assistantConfig$.value` must be available.
+     * - `WS_REQUEST_URL` must be defined.
+     *
+     * If these preconditions are not met, an error is logged to the console.
+     *
+     * @private
+     */
+    _initSignalRConnectionService() {
+        if (this.assistantConfig$.value && this.WS_REQUEST_URL) {
+            const signalROpConfig = {
+                getWsRequestUrl: () => this.WS_REQUEST_URL,
+                getAssistantConfigValue: () => this.assistantConfig$.value,
+                getHubConnection: () => this.connection, // Using getHubConnection as per user's file
+                setHubConnection: (conn) => { this.connection = conn; }
+            };
+            this.signalRConnectionService.init(signalROpConfig);
+        }
+        else {
+            // This case should ideally not happen if init order is correct
+            console.error("Cannot initialize SignalRConnectionService: assistantConfig or WS_REQUEST_URL not ready.");
+        }
+    }
+    /**
+     * Initializes the Assistant Configuration Service with the necessary operation context.
+     * This method sets up the configuration context by providing various utility functions
+     * and state management mechanisms required for the assistant's configuration operations.
+     *
+     * The operation context includes:
+     * - Methods to retrieve chat instance and chat IDs.
+     * - Methods to get and set assistant configuration values.
+     * - Methods to set WebSocket and REST request URLs.
+     * - Methods to update the initialization configuration status.
+     * - A method to generate audit events for tracking operations.
+     *
+     * @private
+     */
+    _initAssistantConfigurationService() {
+        const configOpContext = {
+            getChatInstanceId: () => this.chatInstanceId,
+            getChatId: () => this.chatId,
+            getAssistantConfigValue: () => this.assistantConfig$.value,
+            setWSRequestsUrl: (url) => this.WS_REQUEST_URL = url,
+            setRESTRequestsUrl: (url) => this.REST_REQUEST_URL = url,
+            setAssistantConfig: (config) => this.assistantConfig$.next(config),
+            setInitConfigStatus: (status) => this.initConfig$.next(status),
+            generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id)
+        };
+        this.assistantConfigurationService.init(configOpContext);
+    }
+    /**
+     * Initializes the AssistantMetadataService with the necessary operation context.
+     *
+     * This method checks if the `assistantConfig$` value and `REST_REQUEST_URL` are available.
+     * If both are ready, it creates an `AssistantMetadataOperationContext` object and
+     * initializes the `assistantMetadataService` with it. The operation context provides
+     * methods to retrieve the REST URL, assistant configuration, and to set models and functions.
+     *
+     * If the required values are not ready, an error is logged to the console.
+     *
+     * @private
+     */
+    _initAssistantMetadataService() {
+        if (this.assistantConfig$.value && this.REST_REQUEST_URL) {
+            const metadataOpContext = {
+                getRestUrl: () => this.REST_REQUEST_URL,
+                getAssistantConfigValue: () => this.assistantConfig$.value,
+                setModels: (models) => { this.models = models; },
+                setFunctions: (functions) => { this.functions = functions; }
+            };
+            this.assistantMetadataService.init(metadataOpContext);
+        }
+        else {
+            console.error("Cannot initialize AssistantMetadataService: assistantConfig or REST_REQUEST_URL not ready.");
+        }
+    }
+    /**
+     * Initializes the Assistant Tokens Tracking Service with the necessary operation context.
+     * This method sets up the service by providing it with functions to manage quotas,
+     * token consumption, usage metrics, and audit events, as well as access to assistant configuration
+     * and model retrieval.
+     *
+     * The initialization will only proceed if the assistant configuration is available.
+     * If the configuration is not ready, an error message is logged to the console.
+     *
+     * @private
+     */
+    _initAssistantTokensTrackingService() {
+        if (this.assistantConfig$.value) {
+            const tokensOpContext = {
+                getAssistantConfigValue: () => this.assistantConfig$.value,
+                setQuota: (quota) => this.quota$.next(quota),
+                setUserTokenConsumption: (consumption) => this.userTokenConsumption$.next(consumption),
+                setChatUsageMetrics: (metrics) => this.chatUsageMetrics$.next(metrics),
+                setChatTokenConsumption: (consumption) => this.chatTokenConsumption$.next(consumption),
+                generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),
+                getModel: (serviceId, modelId) => this.getModel(serviceId, modelId)
+            };
+            this.assistantTokensTrackingService.init(tokensOpContext);
+        }
+        else {
+            console.error("Cannot initialize AssistantTokensTrackingService: assistantConfig not ready.");
+        }
+    }
+    /**
+     * Initializes the Assistant WebSocket Frames Service with the necessary operation context.
+     * This method sets up the required dependencies and configuration for the service to function properly.
+     * It ensures that the assistant configuration and connection are available before initializing the service.
+     *
+     * The operation context provides various utility functions and state management methods, including:
+     * - Accessing the assistant configuration, chat instance ID, saved chat ID, and chat history.
+     * - Managing streaming and stopping generation statuses.
+     * - Updating quota and chat usage metrics.
+     * - Generating audit events.
+     * - Managing saved chats (adding, updating, and listing).
+     *
+     * If the required dependencies (`assistantConfig$` and `connection`) are not ready, an error is logged.
+     *
+     * @private
+     */
+    _initAssistantWsFramesService() {
+        if (this.assistantConfig$.value && this.connection) {
+            const wsFramesOpContext = {
+                getAssistantConfig: () => this.assistantConfig$.value,
+                getChatInstanceId: () => this.chatInstanceId,
+                getChatId: () => this.chatId,
+                getHubConnection: () => this.connection,
+                getChatHistory: () => this.chatHistory,
+                setStreamingStatus: (isStreaming) => this.streaming$.next(isStreaming),
+                setChatHistory: (history) => { this.chatHistory = history; },
+                setStoppingGenerationStatus: (isStopping) => this.stoppingGeneration$.next(isStopping),
+                setSavedChatsErrorStatus: (hasError) => this.savedChatsError$.next(hasError),
+                updateQuota: (quota, propagateError) => this.updateQuota(quota, propagateError),
+                updateChatUsageMetrics: (metrics) => this.updateChatUsageMetrics(metrics),
+                generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),
+                addSavedChat: (id, messages) => this.addSavedChat(id, messages),
+                updateSavedChat: (id, name, messages) => this.updateSavedChat(id, name, messages),
+                listSavedChat: () => this.listSavedChat(),
+                isExistingSavedChat: (id) => this.isExistingSavedChat(id)
+            };
+            this.assistantWsFramesService.init(wsFramesOpContext);
+        }
+        else {
+            console.error("Cannot initialize AssistantWsFramesService: core dependencies not ready.");
+        }
+    }
+    _initDebugMessageService() {
+        if (this.assistantConfig$.value && this.REST_REQUEST_URL) {
+            const debugMessageOpContext = {
+                getRestUrl: () => this.REST_REQUEST_URL
+            };
+            this.debugMessageService.init(debugMessageOpContext);
+        }
+        else {
+            console.error("Cannot initialize DebugMessageService: assistantConfig or REST_REQUEST_URL not ready.");
+        }
+    }
     get assistants() {
-        if (!this.userSettingsService.userSettings)
-            this.userSettingsService.userSettings = {};
-        if (!this.userSettingsService.userSettings["assistants"])
-            this.userSettingsService.userSettings["assistants"] = {};
-        return this.userSettingsService.userSettings["assistants"];
+        return this.assistantConfigurationService.getAssistantsSetting();
     }
     /**
      * Get the instance ID of the chat service
@@ -74,29 +347,14 @@ export class ChatService {
         this._chatInstanceId = instanceId;
     }
     /**
-     * Get the ID of the current chat discussion which is used to save/get/delete it
-     * @returns The ID of the current chat discussion
-     */
-    get savedChatId() {
-        return this._savedChatId;
-    }
-    /**
-     * Persist the ID of the current chat discussion which is used to save/get/delete it
-     * @param savedChatId The ID of the current chat discussion which is used to save/get/delete it
-     */
-    setSavedChatId(savedChatId) {
-        this._savedChatId = savedChatId;
-    }
-    /**
-     * Get the ID of the current chat discussion which is used to identify audit events
+     * Get the ID of the current chat discussion which is used to save/get/delete the discussion and identify audit events
      * @returns The ID of the current chat discussion
      */
     get chatId() {
         return this._chatId;
     }
     /**
-     * Generate an GUID for the current chat discussion which is used to identify audit events
-     * If the discussion is saved, the savedChatId is initialized with the value of this chatId
+     * Generate an GUID for the current chat discussion which is used to save/get/delete it and identify audit events
      * @param chatId if provided, it will be considered as the ID of the current chat discussion which is used to identify audit events
      */
     generateChatId(chatId) {
@@ -110,66 +368,7 @@ export class ChatService {
      * This provide a centralized way to manage the rest of the config object by admins and ensure a unique common behavior for all users.
      */
     async initChatConfig() {
-        // fetch the standard app config to get the defaultValues of the chat config for the given instance
-        // Persist the app in the app service
-        const capp = await fetchApp();
-        this.appService.app = capp;
-        const settings = await fetchUserSettings();
-        this.userSettingsService.userSettings = settings;
-        const key = this.chatInstanceId;
-        const userSettingsConfig = this.assistants[key] || {};
-        const principal = await fetchPrincipal();
-        this.principalService.principal = principal;
-        const standardChatConfig = getAssistantJsonFromCCApp(this.appService.app, key);
-        try {
-            // Validate the whole config object against the schema
-            chatConfigSchema.parse(standardChatConfig);
-            // If the user preferences do not contain a config's defaultValues object, keep using the standard app config and nothing to store in the user preferences
-            if (!userSettingsConfig.defaultValues) {
-                this.assistantConfig$.next({ ...standardChatConfig });
-                this.initConfig$.next(true);
-            }
-            else { // If the user has its own defaultValues in its userSettings, then we need to check for potential updates made by admins in the meantime and how he wants to manage them
-                // Retrieve already stored hashes in the user settings if exists
-                const appliedDefaultValuesHash = userSettingsConfig.hashes?.["applied-defaultValues-hash"];
-                const skippedDefaultValuesHash = userSettingsConfig.hashes?.["skipped-defaultValues-hash"];
-                // Create a hash of the current defaultValues of the standardChatConfig
-                const currentDefaultValuesHash = await sha512(JSON.stringify(standardChatConfig.defaultValues));
-                // Implement the tracking mechanism to notify the user about the available updates in the defaultValues object of the standard app config
-                const condition = (currentDefaultValuesHash !== appliedDefaultValuesHash) && (currentDefaultValuesHash !== skippedDefaultValuesHash);
-                if (condition) {
-                    this.modalService.open(DialogUpdatesComponent)
-                        .then(res => {
-                        if (res === "dialog-confirm") {
-                            const hashes = { ...userSettingsConfig.hashes, "applied-defaultValues-hash": currentDefaultValuesHash, "skipped-defaultValues-hash": undefined };
-                            // Update the chat config and store its defaultValues in the user preferences
-                            this.updateChatConfig({ ...standardChatConfig }, hashes, true);
-                            this.initConfig$.next(true);
-                            this.generateAuditEvent("ast-configuration.click", { 'configuration': JSON.stringify({ ...standardChatConfig }) });
-                        }
-                        else if (res === "dialog-no") {
-                            // Do not notify the user about changes while this skipped version is not updated
-                            const hashes = { ...userSettingsConfig.hashes, "skipped-defaultValues-hash": currentDefaultValuesHash };
-                            this.updateChatConfig({ ...standardChatConfig, defaultValues: userSettingsConfig.defaultValues }, hashes, false);
-                            this.initConfig$.next(true);
-                        }
-                        else {
-                            // Just pick the version in the user settings, nothing to be updated
-                            this.assistantConfig$.next({ ...standardChatConfig, defaultValues: userSettingsConfig.defaultValues });
-                            this.initConfig$.next(true);
-                        }
-                    });
-                }
-                else { // No available updates Or updates has been already skipped, then just pick the version in the user settings
-                    this.assistantConfig$.next({ ...standardChatConfig, defaultValues: userSettingsConfig.defaultValues });
-                    this.initConfig$.next(true);
-                }
-            }
-        }
-        catch (error) {
-            this.notificationsService.error(`Missing valid configuration for the assistant instance '${key}'. See the browser console messages for details on the missing or incorrect properties.`);
-            throw new Error(`Missing valid configuration for the assistant instance '${key}' . \n ${JSON.stringify(error.issues, null, 2)}`);
-        }
+        this.assistantConfigurationService.initChatConfig();
     }
     /**
      * Update the chat config and store its defaultValues in the user preferences
@@ -180,28 +379,55 @@ export class ChatService {
      * @param errorCallback  The callback to execute if the update fails
      */
     updateChatConfig(config, hashes, notify = true, successCallback, errorCallback) {
-        this.assistantConfig$.next(config);
-        const assistants = Object.assign({}, this.assistants);
-        assistants[this.chatInstanceId] = { ...assistants[this.chatInstanceId], defaultValues: config.defaultValues };
-        if (hashes)
-            assistants[this.chatInstanceId].hashes = hashes;
-        this.userSettingsService.patch({ assistants }).subscribe(next => { }, error => {
-            if (notify) {
-                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                errorCallback
-                    ? errorCallback()
-                    : this.notificationsService.error(this.transloco.translate('chat.saveChatConfig.fail', { value: this.chatInstanceId }));
-            }
-            console.error("Could not patch assistants!", error);
-        }, () => {
-            if (notify) {
-                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                successCallback
-                    ? successCallback()
-                    : this.notificationsService.success(this.transloco.translate('chat.saveChatConfig.success', { value: this.chatInstanceId }));
-            }
+        this.assistantConfigurationService.updateChatConfig(config, hashes, notify, successCallback, errorCallback);
+    }
+    /**
+     * Overrides the logged in user
+     */
+    overrideUser() {
+        const { userOverrideActive, userOverride } = globalConfig;
+        if (!(userOverrideActive && userOverride)) {
+            this.userOverride$.next(false);
+            return;
+        }
+        // Prepare the payload to send to the OverrideUser method
+        const data = {
+            instanceId: this.chatInstanceId,
+            user: userOverride.username,
+            domain: userOverride.domain
+        };
+        // Invoke the OverrideUser method and handle errors
+        this.connection.invoke('OverrideUser', data)
+            .then((res) => this.userOverride$.next(!!res))
+            .catch(error => {
+            console.error('Error invoking OverrideUser:', error);
+            return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection when no further error handling exists downstream
         });
     }
+    /**
+     * Calls the Fetch API to retrieve a new message given all previous messages
+     */
+    fetch(messages, query) {
+        return this.assistantWsFramesService.fetch(messages, query);
+    }
+    /**
+     * Return the list of models available on the server
+     */
+    listModels() {
+        return this.assistantMetadataService.listModels();
+    }
+    /**
+     * Return the list of functions available on the server AND matching enabled functions in the chat config
+     */
+    listFunctions() {
+        return this.assistantMetadataService.listFunctions();
+    }
+    /**
+     * Stops the assistant answer generation and cancels all the ongoing and pending related tasks
+     */
+    stopGeneration() {
+        return this.assistantWsFramesService.stopGeneration();
+    }
     /**
      * A handler for quota updates each time the chat is invoked.
      * It emits the updated quota to the quota$ subject, emits accordingly the updated user's tokens consumption and notifies the user if the max quota is reached.
@@ -209,17 +435,7 @@ export class ChatService {
      * @param propagateError Whether to propagate the error to the caller
      */
     updateQuota(quota, propagateError = false) {
-        this.quota$.next(quota);
-        const nextResetDate = this.formatDateTime(quota.nextResetUTC + "+00:00"); // This +00:00 is to ensure dates will be properly converted to local time
-        const consumptionPercentage = Math.round((quota.tokenCount * 100 / quota.periodTokens) * 100) / 100;
-        this.userTokenConsumption$.next({ percentage: consumptionPercentage, nextResetDate });
-        if (quota.maxQuotaReached) {
-            this.generateAuditEvent('ast-quota.exceeded', {});
-            const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${nextResetDate}.`;
-            this.notificationsService.error(msg);
-            if (propagateError)
-                throw new Error(msg);
-        }
+        this.assistantTokensTrackingService.updateQuota(quota, propagateError);
     }
     /**
      * A handler for chat usage metrics each time the generation of the assistant response is completed.
@@ -227,10 +443,7 @@ export class ChatService {
      * @param chatUsageMetrics The chat usage metrics
      */
     updateChatUsageMetrics(chatUsageMetrics) {
-        this.chatUsageMetrics$.next(chatUsageMetrics);
-        const currentModel = this.getModel(this.assistantConfig$.value.defaultValues.service_id, this.assistantConfig$.value.defaultValues.model_id);
-        const consumptionPercentage = Math.round((chatUsageMetrics.totalTokenCount * 100 / (currentModel.contextWindowSize - currentModel.maxGenerationSize)) * 100) / 100;
-        this.chatTokenConsumption$.next({ percentage: consumptionPercentage });
+        this.assistantTokensTrackingService.updateChatUsageMetrics(chatUsageMetrics);
     }
     /**
      * Get the model description for the given (serviceId + modelId)
@@ -248,6 +461,110 @@ export class ChatService {
         }
         return model;
     }
+    /**
+     * Fetch the list saved chats belonging to a specific instance of the assistant
+     */
+    listSavedChat() {
+        this.savedChatsService.listChats();
+    }
+    /**
+     * Return the saved chat with the given id, if exists. Otherwise, return undefined
+     * @param id The id of the saved chat
+     */
+    getSavedChat(id) {
+        return this.savedChatsService.getChatById(id);
+    }
+    /**
+     * Check if a saved chat with the given id already exists
+     * @param id The id of the saved chat
+     * @returns True if the saved chat exists, false otherwise
+     */
+    isExistingSavedChat(id) {
+        return this.savedChatsService.isExistingChat(id);
+    }
+    /**
+     * Save a chat with the given messages
+     * @param messages The messages to add to the saved chat index
+     * @returns The saved chat
+     */
+    addSavedChat(id, messages) {
+        return this.savedChatsService.addChat(id, messages);
+    }
+    /**
+     * Update a saved chat with the given id.
+     * @param id The id of the saved chat
+     * @param name The new name of the saved chat, if provided
+     * @param messages The messages to update the saved chat history, if provided
+     * @returns True if the saved chat has been successfully updated
+     */
+    updateSavedChat(id, name, messages) {
+        return this.savedChatsService.updateChat(id, name, messages);
+    }
+    /**
+     * Bulk delete of saved chats matching the given ids
+     * @param ids List of ids of the saved chats to delete
+     * @returns The number of deleted chats
+     */
+    deleteSavedChat(ids) {
+        return this.savedChatsService.deleteChat(ids);
+    }
+    getDebugMessage(message) {
+        return this.debugMessageService.getDebugMessage(message);
+    }
+    /**
+     * Initialize out-of-the-box handlers
+     * It is a placeholder for non-streaming scenarios, where you invoke a specific hub method, and the server responds with frame message(s)
+     */
+    initMessageHandlers() {
+        this.assistantWsFramesService.initMessageHandlers();
+    }
+    /**
+     * Override and register the entire _messageHandlers map by merging the provided map with the default one
+     * @param _messageHandlers
+     */
+    overrideMessageHandlers(_messageHandlers) {
+        this.assistantWsFramesService.overrideMessageHandlers(_messageHandlers);
+    }
+    /**
+     * Add a listener for a specific event.
+     * If a listener for this same event already exists, it will be overridden.
+     * If the listener has "isGlobalHandler" set to true, it will be registered to the hub connection.
+     * @param eventName Name of the event to register a listener for
+     * @param eventHandler The handler to be called when the event is received
+     */
+    addMessageHandler(eventName, eventHandler) {
+        this.assistantWsFramesService.addMessageHandler(eventName, eventHandler);
+    }
+    /**
+     * Remove a listener for a specific event from the _messageHandlers map and unsubscribe from receiving messages for this event from the SignalR hub.
+     * @param eventName Name of the event to remove the listener for
+     */
+    removeMessageHandler(eventName) {
+        this.assistantWsFramesService.removeMessageHandler(eventName);
+    }
+    /**
+     * Build a connection to the signalR websocket and register default listeners to the methods defined in the server hub class
+     * @param options The options for the connection. It overrides the default options
+     * @param logLevel Define the log level displayed in the console
+     * @returns Promise that resolves when the connection is built
+     */
+    buildConnection(options) {
+        return this.signalRConnectionService.buildConnection(options);
+    }
+    /**
+     * Start the connection
+     * @returns Promise that resolves when the connection is started
+     */
+    startConnection() {
+        return this.signalRConnectionService.startConnection();
+    }
+    /**
+     * Stop the connection
+     * @returns Promise that resolves when the connection is stopped
+     */
+    stopConnection() {
+        return this.signalRConnectionService.stopConnection();
+    }
     /**
      * Generate an audit event with the given type and details. The generated audit event is sent afterwards via the AuditWebService
      * @param type Audit event type
@@ -262,9 +579,11 @@ export class ChatService {
             "instance-id": this.chatInstanceId,
             "chat-id": id || this.chatId,
             "service-id": this.assistantConfig$.value.defaultValues.service_id,
-            "model-id": this.assistantConfig$.value.defaultValues.model_id,
-            "is-user-input": false
+            "model-id": this.assistantConfig$.value.defaultValues.model_id
         };
+        if (type === "ast-message.message") {
+            baseDetails["is-user-input"] = false;
+        }
         const audit = {
             type,
             detail: {
@@ -272,143 +591,7 @@ export class ChatService {
                 ...details
             }
         };
-        const response = await Audit.notify(audit);
-        console.log("Audit response", response);
-    }
-    /**
-     * Traverse the array from the end and track the first 'assistant' message among the last group of "assistant" messages where display is true
-     * @param array The array of ChatMessage to traverse
-     * @returns The index of the first visible assistant message among the last group of "assistant" messages in the array
-     */
-    firstVisibleAssistantMessageIndex(array) {
-        if (!array) {
-            return -1;
-        }
-        let index = array.length - 1;
-        let firstVisibleAssistantMessageIndex = -1;
-        while (index >= 0 && array[index].role === 'assistant') {
-            if (array[index].additionalProperties.display === true) {
-                firstVisibleAssistantMessageIndex = index;
-            }
-            index--;
-        }
-        return firstVisibleAssistantMessageIndex;
-    }
-    /**
-     * Traverse the array from the end and pick the last 'assistant' message among the last group of "assistant" messages where display is true
-     * @param array The array of ChatMessage to traverse
-     * @returns The index of the last visible assistant message among the last group of "assistant" messages in the array
-     */
-    lastVisibleAssistantMessageIndex(array) {
-        if (!array) {
-            return -1;
-        }
-        let index = array.length - 1;
-        let lastVisibleAssistantMessageIndex = -1;
-        while (index >= 0 && array[index].role === 'assistant') {
-            if (array[index].additionalProperties.display === true) {
-                lastVisibleAssistantMessageIndex = index;
-                break;
-            }
-            index--;
-        }
-        return lastVisibleAssistantMessageIndex;
-    }
-    /**
-     * Format a date string in UTC to a local date string
-     * @param value Date string in UTC to format
-     * @returns A formatted local date string
-     */
-    formatDateTime(value) {
-        const localDate = toDate(parseISO(value));
-        const formatter = new Intl.DateTimeFormat(undefined, {
-            year: 'numeric',
-            month: 'short',
-            day: 'numeric',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-            timeZoneName: 'short'
-        });
-        return formatter.format(localDate);
-    }
-    /**
-   * Takes a text prompt that may contain placeholders for variables
-   * and replaces these placeholders if it finds a match in the given
-   * context object.
-   *
-   * @example
-   * const p = "Hello, [[user.name]]! You have [[user.notifications.length]] new notifications.";
-   * const context = {
-   *     user: {
-   *         name: "Alice",
-   *         notifications: ["Message from Bob", "Reminder for meeting"]
-   *     }
-   * };
-   * const formattedPrompt = formatPrompt(p, context);
-   * console.log(formattedPrompt); // Output: "Hello, Alice! You have 2 new notifications."
-   */
-    static formatPrompt(prompt, context) {
-        return prompt.replace(/\[\[(.*?)\]\]/g, (match, expr) => {
-            // Simple dot notation resolver
-            const keys = expr.trim().split(".");
-            let value = context;
-            for (const key of keys) {
-                if (value && typeof value === "object" && key in value) {
-                    value = value[key];
-                }
-                else {
-                    return match;
-                }
-            }
-            return value ?? match;
-        });
-    }
-    /**
-     * Determines a time-based key for a given date to be used for translations or formatting.
-     * The key represents a relative time period such as "today", "yesterday", "this week", etc.
-     * If the date does not fall into any predefined relative time period, it returns the year as a string.
-     *
-     * @param date - The date for which the time key is to be determined.
-     * @returns A string representing the time key, which can be used for translation or display purposes.
-     */
-    getTimeKey(date) {
-        if (isToday(date)) {
-            return this.transloco.translate('chat.today');
-        }
-        else if (isYesterday(date)) {
-            return this.transloco.translate('chat.yesterday');
-        }
-        else if (isThisWeek(date)) {
-            return this.transloco.translate('chat.thisWeek');
-        }
-        else if (differenceInDays(endOfYesterday(), date) <= 7) {
-            return this.transloco.translate('chat.lastWeek');
-        }
-        else if (isThisMonth(date)) {
-            return this.transloco.translate('chat.thisMonth');
-        }
-        else if (differenceInMonths(endOfYesterday(), date) <= 1) {
-            return this.transloco.translate('chat.lastMonth');
-        }
-        else if (isThisQuarter(date)) {
-            return this.transloco.translate('chat.thisQuarter');
-        }
-        else if (differenceInMonths(endOfYesterday(), date) <= 3) {
-            return this.transloco.translate('chat.lastQuarter');
-        }
-        else if (isThisYear(date)) {
-            return this.transloco.translate('chat.thisYear');
-        }
-        else if (differenceInYears(endOfYesterday(), date) === 1) {
-            return this.transloco.translate('chat.lastYear');
-        }
-        else {
-            return format(date, 'yyyy');
-        }
-    }
-    getCurrentLocaleName() {
-        return this.localID || '';
+        await Audit.notify(audit);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ChatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ChatService }); }
@@ -416,4 +599,4 @@ export class ChatService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ChatService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat.service.js","sourceRoot":"","sources":["../../../../projects/assistant/chat/chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, LOCALE_ID, inject } from \"@angular/core\";\nimport { TranslocoService } from \"@jsverse/transloco\";\nimport { differenceInDays, differenceInMonths, differenceInYears, endOfYesterday, format, isThisMonth, isThisQuarter, isThisWeek, isThisYear, isToday, isYesterday, parseISO, toDate } from \"date-fns\";\nimport { BehaviorSubject, Observable } from \"rxjs\";\n\nimport { Audit, Query, fetchApp, fetchPrincipal, fetchUserSettings, guid, sha512 } from \"@sinequa/atomic\";\n\nimport { DialogUpdatesComponent } from \"./dialogs/updates.component\";\nimport { AppService } from \"./services/app.service\";\nimport { DialogService } from \"./services/dialog.service\";\nimport { NotificationsService } from \"./services/notification.service\";\nimport { PrincipalService } from \"./services/principal.service\";\nimport { UserSettingsWebService } from \"./services/user-settings.service\";\nimport { ChatConfig, ChatMessage, ChatResponse, ChatUsageMetrics, DeleteSavedChatResponse, GllmFunction, GllmModelDescription, Quota, SavedChat, SavedChatHistory, SavedChatResponse, TokenConsumption, UserTokenConsumption, chatConfigSchema } from \"./types\";\nimport { getAssistantJsonFromCCApp } from \"./utils/assistant-json\";\n\n@Injectable()\nexport abstract class ChatService {\n\n  readonly localID = inject(LOCALE_ID, {optional: true});\n\n  /** Name of the assistant plugin OR websocket endpoint. */\n  REQUEST_URL: string;\n  /** Emit true once the initialization of the assistant process is done. */\n  initProcess$ = new BehaviorSubject<boolean>(false);\n  /** Emit true once the initialization of the assistant config is done. */\n  initConfig$ = new BehaviorSubject<boolean>(false);\n  /** Emit the global configuration of the assistant. */\n  assistantConfig$ = new BehaviorSubject<ChatConfig | undefined>(undefined);\n  /** Emit true if the user has been overridden, false otherwise. */\n  userOverride$ = new BehaviorSubject<boolean | undefined>(undefined);\n  /**\n   * Emit true if the fetch of an assistant's response is ongoing (it includes Streaming status of the assistant endpoint AND saving the discussion if save Chat is enabled).\n   * This is used to prevent multiple fetches at the same time.\n   * Typically, there is no problem chaining fetches, but when forcing a reload after query changes cases, it can't be allowed because it breaks the whole business logic.\n  */\n  streaming$ = new BehaviorSubject<boolean>(false);\n  /** Store the messages history of the current chat. */\n  chatHistory: ChatMessage[] | undefined;\n  /** List of models available on the server. */\n  models: GllmModelDescription[] | undefined;\n  /** List of functions available on the server. */\n  functions: GllmFunction[] | undefined;\n  /** List of saved chats. */\n  savedChats$ = new BehaviorSubject<SavedChat[]>([]);\n  /** Whether there is an error with saved chats. */\n  savedChatsError$ = new BehaviorSubject<boolean>(false);\n  /** Emit the saved chat to load. */\n  loadSavedChat$ = new BehaviorSubject<SavedChat | undefined>(undefined);\n  /** Emit the quota each time the chat is invoked. */\n  quota$ = new BehaviorSubject<Quota | undefined>(undefined);\n  /** Emit the calculated user's token consumption based on the quota. */\n  userTokenConsumption$ = new BehaviorSubject<UserTokenConsumption | undefined>(undefined);\n  /** Emit the chat usage metrics each time the generation of the assistant response is completed. */\n  chatUsageMetrics$ = new BehaviorSubject<ChatUsageMetrics | undefined>(undefined);\n  /** Emit the calculated chat's token consumption based on the chat usage metrics. */\n  chatTokenConsumption$ = new BehaviorSubject<TokenConsumption | undefined>(undefined);\n  /** Emit true if \"CancelTasks\" is ongoing. */\n  stoppingGeneration$ = new BehaviorSubject<boolean>(false);\n  /** Instance ID of the chat service defining the assistant instance. */\n  private _chatInstanceId: string;\n  /** ID of the current **saved chat** discussion which is used to update/get/delete it. */\n  private _savedChatId: string | undefined;\n  /** Generated GUID for the current non-saved chat discussion used to identify audit events.\n   * If the chat is saved, the savedChatId is initialized with the value of this chatId.\n   */\n  private _chatId: string;\n\n  public userSettingsService = inject(UserSettingsWebService);\n  public notificationsService = inject(NotificationsService);\n  public appService = inject(AppService);\n  public modalService = inject(DialogService);\n  public principalService = inject(PrincipalService);\n  protected readonly transloco = inject(TranslocoService);\n  /**\n   * Initialize the chat process\n   */\n  abstract init(): Observable<boolean>;\n\n  /**\n   * Initialize the REQUEST_URL\n   */\n  abstract getRequestsUrl(): void;\n\n  get assistants(): any {\n    if (!this.userSettingsService.userSettings)\n      this.userSettingsService.userSettings = {};\n    if (!this.userSettingsService.userSettings[\"assistants\"])\n      this.userSettingsService.userSettings[\"assistants\"] = {};\n    return  this.userSettingsService.userSettings[\"assistants\"];\n  }\n\n  /**\n   * Get the instance ID of the chat service\n   * @returns The instance ID of the chat service\n   */\n  get chatInstanceId(): string {\n    return this._chatInstanceId;\n  }\n\n  /**\n   * Persist the instance ID of the chat service\n   * @param instanceId The instance ID of the chat service\n   */\n  setChatInstanceId(instanceId: string) {\n    this._chatInstanceId = instanceId;\n  }\n\n  /**\n   * Get the ID of the current chat discussion which is used to save/get/delete it\n   * @returns The ID of the current chat discussion\n   */\n  get savedChatId(): string | undefined {\n    return this._savedChatId;\n  }\n\n  /**\n   * Persist the ID of the current chat discussion which is used to save/get/delete it\n   * @param savedChatId The ID of the current chat discussion which is used to save/get/delete it\n   */\n  setSavedChatId(savedChatId: string | undefined) {\n    this._savedChatId = savedChatId;\n  }\n\n  /**\n   * Get the ID of the current chat discussion which is used to identify audit events\n   * @returns The ID of the current chat discussion\n   */\n  get chatId(): string {\n    return this._chatId;\n  }\n\n  /**\n   * Generate an GUID for the current chat discussion which is used to identify audit events\n   * If the discussion is saved, the savedChatId is initialized with the value of this chatId\n   * @param chatId if provided, it will be considered as the ID of the current chat discussion which is used to identify audit events\n   */\n  generateChatId(chatId?: string) {\n    this._chatId = chatId || guid();\n  }\n\n  /**\n   * Initialize the chat config by managing ONLY sub-object **defaultValues** configs of the standard app config (defined in the customization json tab ) and the user preferences.\n   * To do so, a tracking mechanism is implemented to notify the user about the available updates in the defaultValues object of the standard app config.\n   * The rest of the config object coming from \"standard app config\" is used as it is without any override.\n   * Thus, the user preferences are used only for the defaultValues object.\n   * This provide a centralized way to manage the rest of the config object by admins and ensure a unique common behavior for all users.\n   */\n  async initChatConfig() {\n    // fetch the standard app config to get the defaultValues of the chat config for the given instance\n    // Persist the app in the app service\n    const capp = await fetchApp();\n    this.appService.app = capp;\n\n    const settings = await fetchUserSettings<{}>();\n    this.userSettingsService.userSettings = settings;\n    const key = this.chatInstanceId;\n    const userSettingsConfig = this.assistants[key] || {};\n\n    const principal = await fetchPrincipal();\n    this.principalService.principal = principal;\n\n    const standardChatConfig = getAssistantJsonFromCCApp(this.appService.app, key);\n\n    try {\n      // Validate the whole config object against the schema\n      chatConfigSchema.parse(standardChatConfig);\n      // If the user preferences do not contain a config's defaultValues object, keep using the standard app config and nothing to store in the user preferences\n      if (!userSettingsConfig.defaultValues) {\n        this.assistantConfig$.next({...standardChatConfig});\n        this.initConfig$.next(true);\n      } else { // If the user has its own defaultValues in its userSettings, then we need to check for potential updates made by admins in the meantime and how he wants to manage them\n\n        // Retrieve already stored hashes in the user settings if exists\n        const appliedDefaultValuesHash = userSettingsConfig.hashes?.[\"applied-defaultValues-hash\"];\n        const skippedDefaultValuesHash = userSettingsConfig.hashes?.[\"skipped-defaultValues-hash\"];\n        // Create a hash of the current defaultValues of the standardChatConfig\n        const currentDefaultValuesHash = await sha512(JSON.stringify(standardChatConfig.defaultValues));\n\n        // Implement the tracking mechanism to notify the user about the available updates in the defaultValues object of the standard app config\n        const condition = (currentDefaultValuesHash !== appliedDefaultValuesHash) && (currentDefaultValuesHash !== skippedDefaultValuesHash);\n        if (condition) {\n          this.modalService.open(DialogUpdatesComponent)\n            .then(res => {\n                if(res === \"dialog-confirm\") {\n                  const hashes = { ...userSettingsConfig.hashes, \"applied-defaultValues-hash\": currentDefaultValuesHash, \"skipped-defaultValues-hash\": undefined };\n                  // Update the chat config and store its defaultValues in the user preferences\n                  this.updateChatConfig({...standardChatConfig}, hashes, true);\n                  this.initConfig$.next(true);\n                  this.generateAuditEvent(\"ast-configuration.click\", { 'configuration': JSON.stringify({...standardChatConfig}) });\n                } else if(res === \"dialog-no\") {\n                  // Do not notify the user about changes while this skipped version is not updated\n                  const hashes = { ...userSettingsConfig.hashes, \"skipped-defaultValues-hash\": currentDefaultValuesHash };\n                  this.updateChatConfig({...standardChatConfig, defaultValues: userSettingsConfig.defaultValues}, hashes, false);\n                  this.initConfig$.next(true);\n                } else {\n                  // Just pick the version in the user settings, nothing to be updated\n                  this.assistantConfig$.next({...standardChatConfig, defaultValues: userSettingsConfig.defaultValues});\n                  this.initConfig$.next(true);\n                }\n            });\n        } else { // No available updates Or updates has been already skipped, then just pick the version in the user settings\n          this.assistantConfig$.next({...standardChatConfig, defaultValues: userSettingsConfig.defaultValues});\n          this.initConfig$.next(true);\n        }\n      }\n    } catch (error) {\n      this.notificationsService.error(`Missing valid configuration for the assistant instance '${key}'. See the browser console messages for details on the missing or incorrect properties.`);\n      throw new Error(`Missing valid configuration for the assistant instance '${key}' . \\n ${JSON.stringify(error.issues, null, 2)}`);\n    }\n  }\n\n  /**\n   * Update the chat config and store its defaultValues in the user preferences\n   * @param config  The updated chat config\n   * @param hashes  The updated hashes to store in the user preferences\n   * @param notify  Whether to notify the user about the update\n   * @param successCallback  The callback to execute if the update is successful\n   * @param errorCallback  The callback to execute if the update fails\n   */\n  updateChatConfig(config: ChatConfig, hashes?: {\"applied-defaultValues-hash\"?: string, \"skipped-defaultValues-hash\"?: string},  notify = true, successCallback?: () => any, errorCallback?: () => any) {\n    this.assistantConfig$.next(config);\n    const assistants = Object.assign({}, this.assistants);\n    assistants[this.chatInstanceId] = { ...assistants[this.chatInstanceId], defaultValues: config.defaultValues };\n    if(hashes) assistants[this.chatInstanceId].hashes = hashes;\n    this.userSettingsService.patch({ assistants }).subscribe(\n      next => {},\n      error => {\n        if(notify) {\n          // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n          errorCallback\n            ? errorCallback()\n            : this.notificationsService.error(this.transloco.translate('chat.saveChatConfig.fail', { value: this.chatInstanceId }));\n        }\n        console.error(\"Could not patch assistants!\", error);\n      },\n      () => {\n        if(notify) {\n          // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n          successCallback\n            ? successCallback()\n            : this.notificationsService.success(this.transloco.translate('chat.saveChatConfig.success', { value: this.chatInstanceId }));\n        }\n      }\n    );\n  }\n\n  /**\n   * Overrides the logged in user\n   */\n  abstract overrideUser(): void;\n\n  /**\n   * Calls the Fetch API to retrieve a new message given all previous messages\n   */\n  abstract fetch(messages: ChatMessage[], query: Query): Observable<ChatResponse>\n\n  /**\n   * Return the list of models available on the server\n   */\n  abstract listModels(): Observable<GllmModelDescription[] | undefined>;\n\n  /**\n   * Return the list of functions available on the server AND matching enabled functions in the chat config\n   */\n  abstract listFunctions(): Observable<GllmFunction[] | undefined>;\n\n  /**\n   * Stops the assistant answer generation and cancels all the ongoing and pending related tasks\n   */\n  abstract stopGeneration(): Observable<any>\n\n  /**\n   * A handler for quota updates each time the chat is invoked.\n   * It emits the updated quota to the quota$ subject, emits accordingly the updated user's tokens consumption and notifies the user if the max quota is reached.\n   * @param quota The updated quota\n   * @param propagateError Whether to propagate the error to the caller\n   */\n  updateQuota(quota: Quota, propagateError = false) {\n    this.quota$.next(quota);\n    const nextResetDate = this.formatDateTime(quota.nextResetUTC+\"+00:00\"); // This +00:00 is to ensure dates will be properly converted to local time\n    const consumptionPercentage = Math.round((quota.tokenCount * 100 / quota.periodTokens) * 100) / 100;\n    this.userTokenConsumption$.next({percentage: consumptionPercentage, nextResetDate});\n    if(quota.maxQuotaReached) {\n      this.generateAuditEvent('ast-quota.exceeded', {});\n      const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${nextResetDate}.`;\n      this.notificationsService.error(msg);\n      if(propagateError) throw new Error(msg);\n    }\n  }\n\n  /**\n   * A handler for chat usage metrics each time the generation of the assistant response is completed.\n   * It emits the chat usage metrics to the chatUsageMetrics$ subject, emits accordingly the updated chat's tokens consumption\n   * @param chatUsageMetrics The chat usage metrics\n   */\n  updateChatUsageMetrics(chatUsageMetrics: ChatUsageMetrics) {\n    this.chatUsageMetrics$.next(chatUsageMetrics);\n    const currentModel = this.getModel(this.assistantConfig$.value!.defaultValues.service_id, this.assistantConfig$.value!.defaultValues.model_id);\n    const consumptionPercentage = Math.round((chatUsageMetrics.totalTokenCount * 100 / (currentModel!.contextWindowSize - currentModel!.maxGenerationSize)) * 100) / 100;\n    this.chatTokenConsumption$.next({percentage: consumptionPercentage});\n  }\n\n  /**\n   * Get the model description for the given (serviceId + modelId)\n   * If a model is not found, an error message is returned\n   * @param serviceId The serviceId of the model\n   * @param modelId The modelId of the model\n   * @returns The model description\n   */\n  getModel(serviceId: string, modelId: string): GllmModelDescription | undefined{\n    const model = this.models?.find(m => m.serviceId === serviceId && m.modelId === modelId);\n    // Handle obsolete config\n    if(!model) {\n      this.notificationsService.error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available. Please contact an admin for further information.`);\n      throw new Error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available`);\n    }\n    return model;\n  }\n\n  /**\n   * Fetch the list saved chats belonging to a specific instance of the assistant\n   */\n  abstract listSavedChat(): void;\n\n  /**\n   * Return the saved chat with the given id, if exists. Otherwise, return undefined\n   * @param id The id of the saved chat\n   */\n  abstract getSavedChat(id: string): Observable<SavedChatHistory | undefined>;\n\n  /**\n   * Save a chat with the given messages\n   * @param messages The messages to add to the saved chat index\n   * @returns The saved chat\n   */\n  abstract addSavedChat(messages: ChatMessage[]): Observable<SavedChatResponse>;\n\n  /**\n   * Update a saved chat with the given id.\n   * @param id The id of the saved chat\n   * @param name The new name of the saved chat, if provided\n   * @param messages The messages to update the saved chat history, if provided\n   * @returns True if the saved chat has been successfully updated\n   */\n  abstract updateSavedChat(id: string, name?: string, messages?: ChatMessage[]): Observable<SavedChatResponse>;\n\n  /**\n   * Bulk delete of saved chats matching the given ids\n   * @param ids List of ids of the saved chats to delete\n   * @returns The number of deleted chats\n   */\n  abstract deleteSavedChat(ids: string[]): Observable<DeleteSavedChatResponse>;\n\n  /**\n   * Generate an audit event with the given type and details. The generated audit event is sent afterwards via the AuditWebService\n   * @param type Audit event type\n   * @param details Audit event details\n   * @param id Actions (savedChat delete/rename/...) may occur on a specific chat different than the current one stored in this service, so the chat id can be provided\n   */\n  async generateAuditEvent(type: string, details: Record<string, any>, id?: string) {\n    const baseDetails = {\n      \"url\": decodeURIComponent(window.location.href),\n      \"app\": this.appService.appName,\n      \"user-id\": this.principalService.principal?.userId,\n      \"instance-id\": this.chatInstanceId,\n      \"chat-id\": id || this.chatId,\n      \"service-id\": this.assistantConfig$.value!.defaultValues.service_id,\n      \"model-id\": this.assistantConfig$.value!.defaultValues.model_id,\n      \"is-user-input\": false\n    };\n    const audit = {\n      type,\n      detail: {\n        ...baseDetails,\n        ...details\n      }\n    }\n    const response = await Audit.notify(audit);\n    console.log(\"Audit response\", response);\n  }\n\n\n\n  /**\n   * Traverse the array from the end and track the first 'assistant' message among the last group of \"assistant\" messages where display is true\n   * @param array The array of ChatMessage to traverse\n   * @returns The index of the first visible assistant message among the last group of \"assistant\" messages in the array\n   */\n  firstVisibleAssistantMessageIndex(array: ChatMessage[]| undefined): number {\n    if (!array) {\n      return -1;\n    }\n    let index = array.length - 1;\n    let firstVisibleAssistantMessageIndex = -1;\n    while (index >= 0 && array[index].role === 'assistant') {\n      if (array[index].additionalProperties.display === true) {\n        firstVisibleAssistantMessageIndex = index;\n      }\n      index--;\n    }\n    return firstVisibleAssistantMessageIndex;\n  }\n\n  /**\n   * Traverse the array from the end and pick the last 'assistant' message among the last group of \"assistant\" messages where display is true\n   * @param array The array of ChatMessage to traverse\n   * @returns The index of the last visible assistant message among the last group of \"assistant\" messages in the array\n   */\n  lastVisibleAssistantMessageIndex(array: ChatMessage[]| undefined): number {\n    if (!array) {\n      return -1;\n    }\n    let index = array.length - 1;\n    let lastVisibleAssistantMessageIndex = -1;\n    while (index >= 0 && array[index].role === 'assistant') {\n      if (array[index].additionalProperties.display === true) {\n        lastVisibleAssistantMessageIndex = index;\n        break;\n      }\n      index--;\n    }\n    return lastVisibleAssistantMessageIndex;\n  }\n\n  /**\n   * Format a date string in UTC to a local date string\n   * @param value Date string in UTC to format\n   * @returns A formatted local date string\n   */\n  protected formatDateTime(value: string): string {\n    const localDate = toDate(parseISO(value));\n    const formatter = new Intl.DateTimeFormat(undefined, {\n      year: 'numeric',\n      month: 'short',\n      day: 'numeric',\n      hour: '2-digit',\n      minute: '2-digit',\n      second: '2-digit',\n      timeZoneName: 'short'\n    });\n    return formatter.format(localDate);\n  }\n\n    /**\n   * Takes a text prompt that may contain placeholders for variables\n   * and replaces these placeholders if it finds a match in the given\n   * context object.\n   *\n   * @example\n   * const p = \"Hello, [[user.name]]! You have [[user.notifications.length]] new notifications.\";\n   * const context = {\n   *     user: {\n   *         name: \"Alice\",\n   *         notifications: [\"Message from Bob\", \"Reminder for meeting\"]\n   *     }\n   * };\n   * const formattedPrompt = formatPrompt(p, context);\n   * console.log(formattedPrompt); // Output: \"Hello, Alice! You have 2 new notifications.\"\n   */\n  static formatPrompt(prompt: string, context: any) {\n    return prompt.replace(\n      /\\[\\[(.*?)\\]\\]/g,\n      (match, expr) => {\n      // Simple dot notation resolver\n      const keys = expr.trim().split(\".\");\n      let value = context;\n      for (const key of keys) {\n        if (value && typeof value === \"object\" && key in value) {\n        value = value[key];\n        } else {\n        return match;\n        }\n      }\n      return value ?? match;\n      }\n    );\n  }\n\n  /**\n   * Determines a time-based key for a given date to be used for translations or formatting.\n   * The key represents a relative time period such as \"today\", \"yesterday\", \"this week\", etc.\n   * If the date does not fall into any predefined relative time period, it returns the year as a string.\n   *\n   * @param date - The date for which the time key is to be determined.\n   * @returns A string representing the time key, which can be used for translation or display purposes.\n   */\n  getTimeKey(date: Date): string {\n      if (isToday(date)) {\n        return this.transloco.translate('chat.today');\n      } else if (isYesterday(date)) {\n        return this.transloco.translate('chat.yesterday');\n      } else if (isThisWeek(date)) {\n        return this.transloco.translate('chat.thisWeek');\n      } else if (differenceInDays(endOfYesterday(), date) <= 7) {\n        return this.transloco.translate('chat.lastWeek');\n      } else if (isThisMonth(date)) {\n        return this.transloco.translate('chat.thisMonth');\n      } else if (differenceInMonths(endOfYesterday(), date) <= 1) {\n        return this.transloco.translate('chat.lastMonth');\n      } else if (isThisQuarter(date)) {\n        return this.transloco.translate('chat.thisQuarter');\n      } else if (differenceInMonths(endOfYesterday(), date) <= 3) {\n        return this.transloco.translate('chat.lastQuarter');\n      } else if (isThisYear(date)) {\n        return this.transloco.translate('chat.thisYear');\n      } else if (differenceInYears(endOfYesterday(), date) === 1) {\n        return this.transloco.translate('chat.lastYear');\n      } else {\n        return format(date, 'yyyy');\n      }\n    }\n\n  getCurrentLocaleName() {\n    return this.localID || '';\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat.service.js","sourceRoot":"","sources":["../../../../projects/assistant/chat/chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\nimport { TranslocoService } from \"@jsverse/transloco\";\nimport {\n  BehaviorSubject,\n  catchError,\n  defer,\n  filter,\n  forkJoin,\n  from,\n  map,\n  Observable,\n  switchMap,\n  take,\n  tap,\n  throwError\n} from \"rxjs\";\nimport { HubConnection } from \"@microsoft/signalr\";\nimport {\n  Audit,\n  Query,\n  guid,\n  globalConfig\n} from \"@sinequa/atomic\";\n\nimport { AppService } from \"./services/app.service\";\nimport { NotificationsService } from \"./services/notification.service\";\nimport { PrincipalService } from \"./services/principal.service\";\nimport { UserSettingsWebService } from \"./services/user-settings.service\";\nimport {\n  ChatConfig,\n  ChatMessage,\n  ChatResponse,\n  ChatUsageMetrics,\n  DebugMessage,\n  DeleteSavedChatResponse,\n  GllmFunction,\n  GllmModelDescription,\n  KvObject,\n  ListObject,\n  MessageHandler,\n  Quota,\n  SavedChat,\n  SavedChatHistory,\n  SavedChatResponse,\n  TokenConsumption,\n  UserTokenConsumption\n} from \"./types\";\nimport { ConnectionOptions } from \"./services/signalR.web.service\";\nimport { AssistantUtils } from \"./utils/utils.service\";\nimport { SavedChatsService, SavedChatsOperationConfig } from \"./saved-chats/saved-chats.service\";\nimport { SignalRConnectionService, SignalRConnectionOperationConfig } from \"./services/signalR-connection.service\";\nimport { AssistantConfigurationService, AssistantConfigurationOperationContext } from \"./services/assistant-configuration.service\";\nimport { AssistantMetadataService, AssistantMetadataOperationContext } from \"./services/assistant-metadata.service\";\nimport { AssistantTokensTrackingService, AssistantTokensTrackingOperationContext } from \"./services/assistant-tokens-tracking.service\";\nimport { AssistantWsFramesService, AssistantWsFramesContext } from \"./services/assistant-ws-frames.service\"; // Added\nimport { DebugMessageOperationConfig, DebugMessageService } from \"./debug-message/debug-message.service\";\n\n@Injectable()\nexport class ChatService {\n\n  /** Name of the assistant websocket endpoint. */\n  WS_REQUEST_URL: string;\n  /** Name of the assistant REST endpoint. */\n  REST_REQUEST_URL: string;\n  /** SignalR connection instance */\n  public connection: HubConnection | undefined;\n  /** Emit true once the initialization of the assistant process is done. */\n  initProcess$ = new BehaviorSubject<boolean>(false);\n  /** Emit true once the initialization of the assistant config is done. */\n  initConfig$ = new BehaviorSubject<boolean>(false);\n  /** Emit the global configuration of the assistant. */\n  assistantConfig$ = new BehaviorSubject<ChatConfig | undefined>(undefined);\n  /** Emit true if the user has been overridden, false otherwise. */\n  userOverride$ = new BehaviorSubject<boolean | undefined>(undefined);\n  /**\n   * Emit true if the fetch of an assistant's response is ongoing (it includes Streaming status of the assistant endpoint AND saving the discussion if save Chat is enabled).\n   * This is used to prevent multiple fetches at the same time.\n   * Typically, there is no problem chaining fetches, but when forcing a reload after query changes cases, it can't be allowed because it breaks the whole business logic.\n  */\n  streaming$ = new BehaviorSubject<boolean>(false);\n  /** Store the messages history of the current chat. */\n  chatHistory: ChatMessage[] | undefined;\n  /** List of models available on the server. */\n  models: GllmModelDescription[] | undefined;\n  /** List of functions available on the server. */\n  functions: GllmFunction[] | undefined;\n  /** List of saved chats. */\n  savedChats$ = new BehaviorSubject<SavedChat[]>([]);\n  /** Whether there is an error with saved chats. */\n  savedChatsError$ = new BehaviorSubject<boolean>(false);\n  /** Emit the saved chat to load. */\n  loadSavedChat$ = new BehaviorSubject<SavedChat | undefined>(undefined);\n  /** Emit the quota each time the chat is invoked. */\n  quota$ = new BehaviorSubject<Quota | undefined>(undefined);\n  /** Emit the calculated user's token consumption based on the quota. */\n  userTokenConsumption$ = new BehaviorSubject<UserTokenConsumption | undefined>(undefined);\n  /** Emit the chat usage metrics each time the generation of the assistant response is completed. */\n  chatUsageMetrics$ = new BehaviorSubject<ChatUsageMetrics | undefined>(undefined);\n  /** Emit the calculated chat's token consumption based on the chat usage metrics. */\n  chatTokenConsumption$ = new BehaviorSubject<TokenConsumption | undefined>(undefined);\n  /** Emit true if \"CancelTasks\" is ongoing. */\n  stoppingGeneration$ = new BehaviorSubject<boolean>(false);\n  /** Instance ID of the chat service defining the assistant instance. */\n  private _chatInstanceId: string;\n  /** Generated GUID for the current chat discussion used to save/get/delete it and identify audit events. */\n  private _chatId: string;\n\n  public userSettingsService = inject(UserSettingsWebService);\n  public notificationsService = inject(NotificationsService);\n  public appService = inject(AppService);\n  public principalService = inject(PrincipalService);\n  public assistantUtils = inject(AssistantUtils);\n  private savedChatsService = inject(SavedChatsService);\n  private signalRConnectionService = inject(SignalRConnectionService);\n  private assistantConfigurationService = inject(AssistantConfigurationService);\n  private assistantMetadataService = inject(AssistantMetadataService);\n  private assistantTokensTrackingService = inject(AssistantTokensTrackingService);\n  private debugMessageService = inject(DebugMessageService);\n  // Inject the AssistantWsFramesService using 'new' to ensure a separate local instance for each ChatService instance\n  private assistantWsFramesService = new(AssistantWsFramesService);\n  protected readonly transloco = inject(TranslocoService);\n\n  /**\n   * Initialize the assistant process.\n   * It includes building and starting a connection, executing parallel requests for models and functions, and handling errors during the process.\n   * ⚠️ This method MUST be called ONLY if the user is loggedIn and once when the assistant is initialized.\n   *\n   * @returns An Observable<boolean> indicating the success of the initialization process.\n   */\n  init(): Observable<boolean> {\n    // Ensure all logic is executed when subscribed to the observable\n    return defer(() => {\n      this._initAssistantConfigurationService();\n      return from(this.initChatConfig());\n    }).pipe(\n      // Wait for the configuration to be initialized\n      switchMap(() => this.initConfig$.pipe(filter(Boolean), take(1))),\n      tap(() => {\n        this.getWSRequestsUrl();\n        this.getRESTRequestsUrl();\n        this._initAssistantMetadataService();\n        this._initAssistantTokensTrackingService();\n        this._initSavedChatsService();\n        this._initDebugMessageService();\n        this._initSignalRConnectionService();\n      }),\n      // Build and start the SignalR connection\n      switchMap(() => this.buildConnection()),\n      tap(() => {\n        // Initialize AssistantWsFramesService here, now that 'this.connection' is set\n        this._initAssistantWsFramesService();\n        this.initMessageHandlers();\n      }),\n      // Start the connection\n      switchMap(() => this.startConnection()),\n      // Fetch metadata in parallel\n      switchMap(() =>\n        forkJoin([\n          this.listModels(),\n          this.listFunctions()\n        ])\n      ),\n      // Map the results of parallel requests to a boolean indicating success\n      map(([models, functions]) => {\n        const result = !!models && !!functions;\n        this.initProcess$.next(result);\n        return result;\n      }),\n      // Any errors during the process are caught, logged, and re-thrown to propagate the error further\n      catchError((error) => {\n        console.error('Error occurred:', error);\n        return throwError(() => error);\n      }),\n      take(1)\n    );\n  }\n\n  /**\n   * Define the endpoint to use for the websocket requests\n   * It can be overridden by the app config\n   */\n  getWSRequestsUrl() {\n    this.assistantConfigurationService.getWSRequestsUrl();\n  }\n\n  /**\n   * Define the endpoint to use for the http requests\n   * It can be overridden by the app config\n   */\n  getRESTRequestsUrl() {\n    this.assistantConfigurationService.getRESTRequestsUrl();\n  }\n\n  /**\n   * Initializes the SavedChatsService with the necessary configuration.\n   *\n   * This method sets up the `SavedChatsService` by providing it with a configuration object\n   * (`SavedChatsOperationConfig`) that includes various callbacks and properties required\n   * for its operation. The initialization will only proceed if both `assistantConfig$` and\n   * `REST_REQUEST_URL` are available.\n   *\n   * The configuration object includes:\n   * - Application name retrieval.\n   * - Instance ID retrieval.\n   * - REST API URL retrieval.\n   * - Debug flag retrieval.\n   * - Chat ID for new saves.\n   * - Saved chats enablement check.\n   * - Methods for setting a saved chat ID, updating the saved chats list, and generating audit events.\n   *\n   * If the required dependencies are not ready, an error is logged to the console.\n   *\n   * @private\n   */\n  private _initSavedChatsService() {\n    if (this.assistantConfig$.value && this.REST_REQUEST_URL) {\n      const savedChatsOpConfig: SavedChatsOperationConfig = {\n        getAppName: () => this.appService.appName,\n        getInstanceId: () => this.chatInstanceId,\n        getRestUrl: () => this.REST_REQUEST_URL,\n        getDebugFlag: () => this.assistantConfig$.value!.defaultValues.debug,\n        isSavedChatsEnabled: () => !!this.assistantConfig$.value?.savedChatSettings.enabled,\n        setSavedChatsErrorStatus: (hasError) => this.savedChatsError$.next(hasError),\n        updateSavedChatsList: (chats) => this.savedChats$.next(chats),\n        generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),\n      };\n      this.savedChatsService.init(savedChatsOpConfig);\n    } else {\n      // This case should ideally not happen if init order is correct\n      console.error(\"Cannot initialize SavedChatsService: assistantConfig or REST_REQUEST_URL not ready.\");\n    }\n  }\n\n  /**\n   * Initializes the SignalR connection service with the necessary configuration.\n   *\n   * This method ensures that the SignalR connection service is properly set up\n   * by providing it with the required configuration values, such as the WebSocket\n   * request URL and assistant configuration. It also manages the SignalR hub connection\n   * instance.\n   *\n   * Preconditions:\n   * - `assistantConfig$.value` must be available.\n   * - `WS_REQUEST_URL` must be defined.\n   *\n   * If these preconditions are not met, an error is logged to the console.\n   *\n   * @private\n   */\n  private _initSignalRConnectionService() {\n    if (this.assistantConfig$.value && this.WS_REQUEST_URL) {\n        const signalROpConfig: SignalRConnectionOperationConfig = {\n            getWsRequestUrl: () => this.WS_REQUEST_URL,\n            getAssistantConfigValue: () => this.assistantConfig$.value,\n            getHubConnection: () => this.connection, // Using getHubConnection as per user's file\n            setHubConnection: (conn) => { this.connection = conn; }\n        };\n        this.signalRConnectionService.init(signalROpConfig);\n    } else {\n      // This case should ideally not happen if init order is correct\n        console.error(\"Cannot initialize SignalRConnectionService: assistantConfig or WS_REQUEST_URL not ready.\");\n    }\n  }\n\n  /**\n   * Initializes the Assistant Configuration Service with the necessary operation context.\n   * This method sets up the configuration context by providing various utility functions\n   * and state management mechanisms required for the assistant's configuration operations.\n   *\n   * The operation context includes:\n   * - Methods to retrieve chat instance and chat IDs.\n   * - Methods to get and set assistant configuration values.\n   * - Methods to set WebSocket and REST request URLs.\n   * - Methods to update the initialization configuration status.\n   * - A method to generate audit events for tracking operations.\n   *\n   * @private\n   */\n  private _initAssistantConfigurationService() {\n    const configOpContext: AssistantConfigurationOperationContext = {\n        getChatInstanceId: () => this.chatInstanceId,\n        getChatId: () => this.chatId,\n        getAssistantConfigValue: () => this.assistantConfig$.value,\n        setWSRequestsUrl: (url) => this.WS_REQUEST_URL = url,\n        setRESTRequestsUrl: (url) => this.REST_REQUEST_URL = url,\n        setAssistantConfig: (config) => this.assistantConfig$.next(config),\n        setInitConfigStatus: (status) => this.initConfig$.next(status),\n        generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id)\n    };\n    this.assistantConfigurationService.init(configOpContext);\n  }\n\n  /**\n   * Initializes the AssistantMetadataService with the necessary operation context.\n   *\n   * This method checks if the `assistantConfig$` value and `REST_REQUEST_URL` are available.\n   * If both are ready, it creates an `AssistantMetadataOperationContext` object and\n   * initializes the `assistantMetadataService` with it. The operation context provides\n   * methods to retrieve the REST URL, assistant configuration, and to set models and functions.\n   *\n   * If the required values are not ready, an error is logged to the console.\n   *\n   * @private\n   */\n  private _initAssistantMetadataService() {\n    if (this.assistantConfig$.value && this.REST_REQUEST_URL) {\n      const metadataOpContext: AssistantMetadataOperationContext = {\n        getRestUrl: () => this.REST_REQUEST_URL,\n        getAssistantConfigValue: () => this.assistantConfig$.value,\n        setModels: (models) => { this.models = models; },\n        setFunctions: (functions) => { this.functions = functions; }\n      };\n      this.assistantMetadataService.init(metadataOpContext);\n    } else {\n      console.error(\"Cannot initialize AssistantMetadataService: assistantConfig or REST_REQUEST_URL not ready.\");\n    }\n  }\n\n  /**\n   * Initializes the Assistant Tokens Tracking Service with the necessary operation context.\n   * This method sets up the service by providing it with functions to manage quotas,\n   * token consumption, usage metrics, and audit events, as well as access to assistant configuration\n   * and model retrieval.\n   *\n   * The initialization will only proceed if the assistant configuration is available.\n   * If the configuration is not ready, an error message is logged to the console.\n   *\n   * @private\n   */\n  private _initAssistantTokensTrackingService() {\n    if (this.assistantConfig$.value) {\n      const tokensOpContext: AssistantTokensTrackingOperationContext = {\n        getAssistantConfigValue: () => this.assistantConfig$.value,\n        setQuota: (quota) => this.quota$.next(quota),\n        setUserTokenConsumption: (consumption) => this.userTokenConsumption$.next(consumption),\n        setChatUsageMetrics: (metrics) => this.chatUsageMetrics$.next(metrics),\n        setChatTokenConsumption: (consumption) => this.chatTokenConsumption$.next(consumption),\n        generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),\n        getModel: (serviceId, modelId) => this.getModel(serviceId, modelId)\n      };\n      this.assistantTokensTrackingService.init(tokensOpContext);\n    } else {\n      console.error(\"Cannot initialize AssistantTokensTrackingService: assistantConfig not ready.\");\n    }\n  }\n\n  /**\n   * Initializes the Assistant WebSocket Frames Service with the necessary operation context.\n   * This method sets up the required dependencies and configuration for the service to function properly.\n   * It ensures that the assistant configuration and connection are available before initializing the service.\n   *\n   * The operation context provides various utility functions and state management methods, including:\n   * - Accessing the assistant configuration, chat instance ID, saved chat ID, and chat history.\n   * - Managing streaming and stopping generation statuses.\n   * - Updating quota and chat usage metrics.\n   * - Generating audit events.\n   * - Managing saved chats (adding, updating, and listing).\n   *\n   * If the required dependencies (`assistantConfig$` and `connection`) are not ready, an error is logged.\n   *\n   * @private\n   */\n  private _initAssistantWsFramesService() {\n    if (this.assistantConfig$.value && this.connection) {\n      const wsFramesOpContext: AssistantWsFramesContext = {\n        getAssistantConfig: () => this.assistantConfig$.value,\n        getChatInstanceId: () => this.chatInstanceId,\n        getChatId: () => this.chatId,\n        getHubConnection: () => this.connection,\n        getChatHistory: () => this.chatHistory,\n        setStreamingStatus: (isStreaming) => this.streaming$.next(isStreaming),\n        setChatHistory: (history) => { this.chatHistory = history; },\n        setStoppingGenerationStatus: (isStopping) => this.stoppingGeneration$.next(isStopping),\n        setSavedChatsErrorStatus: (hasError) => this.savedChatsError$.next(hasError),\n        updateQuota: (quota, propagateError) => this.updateQuota(quota, propagateError),\n        updateChatUsageMetrics: (metrics) => this.updateChatUsageMetrics(metrics),\n        generateAuditEvent: (type, details, id) => this.generateAuditEvent(type, details, id),\n        addSavedChat: (id, messages) => this.addSavedChat(id, messages),\n        updateSavedChat: (id, name, messages) => this.updateSavedChat(id, name, messages),\n        listSavedChat: () => this.listSavedChat(),\n        isExistingSavedChat: (id) => this.isExistingSavedChat(id)\n      };\n      this.assistantWsFramesService.init(wsFramesOpContext);\n    } else {\n        console.error(\"Cannot initialize AssistantWsFramesService: core dependencies not ready.\");\n    }\n  }\n\n  private _initDebugMessageService() {\n    if (this.assistantConfig$.value && this.REST_REQUEST_URL) {\n      const debugMessageOpContext: DebugMessageOperationConfig = {\n        getRestUrl: () => this.REST_REQUEST_URL\n      };\n      this.debugMessageService.init(debugMessageOpContext);\n    } else {\n      console.error(\"Cannot initialize DebugMessageService: assistantConfig or REST_REQUEST_URL not ready.\");\n    }\n  }\n\n  get assistants(): any {\n    return this.assistantConfigurationService.getAssistantsSetting();\n  }\n\n  /**\n   * Get the instance ID of the chat service\n   * @returns The instance ID of the chat service\n   */\n  get chatInstanceId(): string {\n    return this._chatInstanceId;\n  }\n\n  /**\n   * Persist the instance ID of the chat service\n   * @param instanceId The instance ID of the chat service\n   */\n  setChatInstanceId(instanceId: string) {\n    this._chatInstanceId = instanceId;\n  }\n\n  /**\n   * Get the ID of the current chat discussion which is used to save/get/delete the discussion and identify audit events\n   * @returns The ID of the current chat discussion\n   */\n  get chatId(): string {\n    return this._chatId;\n  }\n\n  /**\n   * Generate an GUID for the current chat discussion which is used to save/get/delete it and identify audit events\n   * @param chatId if provided, it will be considered as the ID of the current chat discussion which is used to identify audit events\n   */\n  generateChatId(chatId?: string) {\n    this._chatId = chatId || guid();\n  }\n\n  /**\n   * Initialize the chat config by managing ONLY sub-object **defaultValues** configs of the standard app config (defined in the customization json tab ) and the user preferences.\n   * To do so, a tracking mechanism is implemented to notify the user about the available updates in the defaultValues object of the standard app config.\n   * The rest of the config object coming from \"standard app config\" is used as it is without any override.\n   * Thus, the user preferences are used only for the defaultValues object.\n   * This provide a centralized way to manage the rest of the config object by admins and ensure a unique common behavior for all users.\n   */\n  async initChatConfig(): Promise<void> {\n    this.assistantConfigurationService.initChatConfig();\n  }\n\n  /**\n   * Update the chat config and store its defaultValues in the user preferences\n   * @param config  The updated chat config\n   * @param hashes  The updated hashes to store in the user preferences\n   * @param notify  Whether to notify the user about the update\n   * @param successCallback  The callback to execute if the update is successful\n   * @param errorCallback  The callback to execute if the update fails\n   */\n  updateChatConfig(\n    config: ChatConfig,\n    hashes?: { \"applied-defaultValues-hash\"?: string; \"skipped-defaultValues-hash\"?: string },\n    notify = true,\n    successCallback?: () => any,\n    errorCallback?: () => any\n  ): void {\n    this.assistantConfigurationService.updateChatConfig(config, hashes, notify, successCallback, errorCallback);\n  }\n\n  /**\n   * Overrides the logged in user\n   */\n  overrideUser(): void {\n    const { userOverrideActive, userOverride } = globalConfig;\n    if (!(userOverrideActive && userOverride)) {\n      this.userOverride$.next(false);\n      return;\n    }\n\n    // Prepare the payload to send to the OverrideUser method\n    const data = {\n      instanceId: this.chatInstanceId,\n      user: userOverride.username,\n      domain: userOverride.domain\n    }\n\n    // Invoke the OverrideUser method and handle errors\n    this.connection!.invoke('OverrideUser', data)\n      .then((res) => this.userOverride$.next(!!res))\n      .catch(error => {\n        console.error('Error invoking OverrideUser:', error);\n        return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection when no further error handling exists downstream\n      });\n  }\n\n  /**\n   * Calls the Fetch API to retrieve a new message given all previous messages\n   */\n  fetch(messages: ChatMessage[], query: Query): Observable<ChatResponse> {\n    return this.assistantWsFramesService.fetch(messages, query);\n  }\n\n  /**\n   * Return the list of models available on the server\n   */\n  listModels(): Observable<GllmModelDescription[] | undefined> {\n    return this.assistantMetadataService.listModels();\n  }\n\n  /**\n   * Return the list of functions available on the server AND matching enabled functions in the chat config\n   */\n  listFunctions(): Observable<GllmFunction[] | undefined> {\n    return this.assistantMetadataService.listFunctions();\n  }\n\n  /**\n   * Stops the assistant answer generation and cancels all the ongoing and pending related tasks\n   */\n  stopGeneration(): Observable<boolean> {\n    return this.assistantWsFramesService.stopGeneration();\n  }\n\n  /**\n   * A handler for quota updates each time the chat is invoked.\n   * It emits the updated quota to the quota$ subject, emits accordingly the updated user's tokens consumption and notifies the user if the max quota is reached.\n   * @param quota The updated quota\n   * @param propagateError Whether to propagate the error to the caller\n   */\n  updateQuota(quota: Quota, propagateError = false): void {\n    this.assistantTokensTrackingService.updateQuota(quota, propagateError);\n  }\n\n  /**\n   * A handler for chat usage metrics each time the generation of the assistant response is completed.\n   * It emits the chat usage metrics to the chatUsageMetrics$ subject, emits accordingly the updated chat's tokens consumption\n   * @param chatUsageMetrics The chat usage metrics\n   */\n  updateChatUsageMetrics(chatUsageMetrics: ChatUsageMetrics): void {\n    this.assistantTokensTrackingService.updateChatUsageMetrics(chatUsageMetrics);\n  }\n\n  /**\n   * Get the model description for the given (serviceId + modelId)\n   * If a model is not found, an error message is returned\n   * @param serviceId The serviceId of the model\n   * @param modelId The modelId of the model\n   * @returns The model description\n   */\n  getModel(serviceId: string, modelId: string): GllmModelDescription | undefined{\n    const model = this.models?.find(m => m.serviceId === serviceId && m.modelId === modelId);\n    // Handle obsolete config\n    if(!model) {\n      this.notificationsService.error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available. Please contact an admin for further information.`);\n      throw new Error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available`);\n    }\n    return model;\n  }\n\n  /**\n   * Fetch the list saved chats belonging to a specific instance of the assistant\n   */\n  listSavedChat(): void {\n    this.savedChatsService.listChats();\n  }\n\n  /**\n   * Return the saved chat with the given id, if exists. Otherwise, return undefined\n   * @param id The id of the saved chat\n   */\n  getSavedChat(id: string): Observable<SavedChatHistory | undefined> {\n    return this.savedChatsService.getChatById(id);\n  }\n\n  /**\n   * Check if a saved chat with the given id already exists\n   * @param id The id of the saved chat\n   * @returns True if the saved chat exists, false otherwise\n   */\n  isExistingSavedChat(id: string): Observable<boolean> {\n    return this.savedChatsService.isExistingChat(id);\n  }\n\n  /**\n   * Save a chat with the given messages\n   * @param messages The messages to add to the saved chat index\n   * @returns The saved chat\n   */\n  addSavedChat(id: string, messages: ChatMessage[]): Observable<SavedChatResponse> {\n    return this.savedChatsService.addChat(id, messages);\n  }\n\n  /**\n   * Update a saved chat with the given id.\n   * @param id The id of the saved chat\n   * @param name The new name of the saved chat, if provided\n   * @param messages The messages to update the saved chat history, if provided\n   * @returns True if the saved chat has been successfully updated\n   */\n  updateSavedChat(id: string, name?: string, messages?: ChatMessage[]): Observable<SavedChatResponse> {\n    return this.savedChatsService.updateChat(id, name, messages);\n  }\n\n  /**\n   * Bulk delete of saved chats matching the given ids\n   * @param ids List of ids of the saved chats to delete\n   * @returns The number of deleted chats\n   */\n  deleteSavedChat(ids: string[]): Observable<DeleteSavedChatResponse> {\n    return this.savedChatsService.deleteChat(ids);\n  }\n\n  public getDebugMessage(message: DebugMessage): Observable<KvObject | ListObject | undefined> {\n    return this.debugMessageService.getDebugMessage(message);\n  }\n\n  /**\n   * Initialize out-of-the-box handlers\n   * It is a placeholder for non-streaming scenarios, where you invoke a specific hub method, and the server responds with frame message(s)\n   */\n  initMessageHandlers(): void {\n    this.assistantWsFramesService.initMessageHandlers();\n  }\n\n  /**\n   * Override and register the entire _messageHandlers map by merging the provided map with the default one\n   * @param _messageHandlers\n   */\n  overrideMessageHandlers<T>(_messageHandlers: Map<string, MessageHandler<T>>): void {\n    this.assistantWsFramesService.overrideMessageHandlers(_messageHandlers);\n  }\n\n  /**\n   * Add a listener for a specific event.\n   * If a listener for this same event already exists, it will be overridden.\n   * If the listener has \"isGlobalHandler\" set to true, it will be registered to the hub connection.\n   * @param eventName Name of the event to register a listener for\n   * @param eventHandler The handler to be called when the event is received\n   */\n  addMessageHandler<T>(eventName: string, eventHandler: MessageHandler<T>): void {\n    this.assistantWsFramesService.addMessageHandler(eventName, eventHandler);\n  }\n\n  /**\n   * Remove a listener for a specific event from the _messageHandlers map and unsubscribe from receiving messages for this event from the SignalR hub.\n   * @param eventName Name of the event to remove the listener for\n   */\n  removeMessageHandler(eventName: string): void {\n    this.assistantWsFramesService.removeMessageHandler(eventName);\n  }\n\n  /**\n   * Build a connection to the signalR websocket and register default listeners to the methods defined in the server hub class\n   * @param options The options for the connection. It overrides the default options\n   * @param logLevel Define the log level displayed in the console\n   * @returns Promise that resolves when the connection is built\n   */\n  buildConnection(options?: ConnectionOptions): Promise<void> {\n    return this.signalRConnectionService.buildConnection(options);\n  }\n\n  /**\n   * Start the connection\n   * @returns Promise that resolves when the connection is started\n   */\n  startConnection(): Promise<void> {\n    return this.signalRConnectionService.startConnection();\n  }\n\n  /**\n   * Stop the connection\n   * @returns Promise that resolves when the connection is stopped\n   */\n  stopConnection(): Promise<void> {\n    return this.signalRConnectionService.stopConnection();\n  }\n\n  /**\n   * Generate an audit event with the given type and details. The generated audit event is sent afterwards via the AuditWebService\n   * @param type Audit event type\n   * @param details Audit event details\n   * @param id Actions (savedChat delete/rename/...) may occur on a specific chat different than the current one stored in this service, so the chat id can be provided\n   */\n  async generateAuditEvent(type: string, details: Record<string, any>, id?: string) {\n    const baseDetails = {\n      \"url\": decodeURIComponent(window.location.href),\n      \"app\": this.appService.appName,\n      \"user-id\": this.principalService.principal?.userId,\n      \"instance-id\": this.chatInstanceId,\n      \"chat-id\": id || this.chatId,\n      \"service-id\": this.assistantConfig$.value!.defaultValues.service_id,\n      \"model-id\": this.assistantConfig$.value!.defaultValues.model_id\n    };\n\n    if (type === \"ast-message.message\") {\n      baseDetails[\"is-user-input\"] = false;\n    }\n\n    const audit = {\n      type,\n      detail: {\n        ...baseDetails,\n        ...details\n      }\n    }\n    await Audit.notify(audit);\n  }\n\n}\n"]}