@sinequa/assistant 3.8.0 → 3.9.0

package/esm2022/chat/chat.service.mjs

@@ -0,0 +1,417 @@
+import { Injectable, LOCALE_ID, 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 { 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 * 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. */
+        this.initConfig$ = new BehaviorSubject(false);
+        /** Emit the global configuration of the assistant. */
+        this.assistantConfig$ = new BehaviorSubject(undefined);
+        /** Emit true if the user has been overridden, false otherwise. */
+        this.userOverride$ = new BehaviorSubject(undefined);
+        /**
+         * 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).
+         * This is used to prevent multiple fetches at the same time.
+         * 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.
+        */
+        this.streaming$ = new BehaviorSubject(false);
+        /** List of saved chats. */
+        this.savedChats$ = new BehaviorSubject([]);
+        /** Emit the saved chat to load. */
+        this.loadSavedChat$ = new BehaviorSubject(undefined);
+        /** Emit the quota each time the chat is invoked. */
+        this.quota$ = new BehaviorSubject(undefined);
+        /** Emit the calculated user's token consumption based on the quota. */
+        this.userTokenConsumption$ = new BehaviorSubject(undefined);
+        /** Emit the chat usage metrics each time the generation of the assistant response is completed. */
+        this.chatUsageMetrics$ = new BehaviorSubject(undefined);
+        /** Emit the calculated chat's token consumption based on the chat usage metrics. */
+        this.chatTokenConsumption$ = new BehaviorSubject(undefined);
+        /** Emit true if "CancelTasks" is ongoing. */
+        this.stoppingGeneration$ = new BehaviorSubject(false);
+        this.userSettingsService = inject(UserSettingsWebService);
+        this.notificationsService = inject(NotificationsService);
+        this.appService = inject(AppService);
+        this.modalService = inject(DialogService);
+        this.principalService = inject(PrincipalService);
+        this.transloco = inject(TranslocoService);
+    }
+    get assistants() {
+        if (!this.userSettingsService.userSettings)
+            this.userSettingsService.userSettings = {};
+        if (!this.userSettingsService.userSettings["assistants"])
+            this.userSettingsService.userSettings["assistants"] = {};
+        return this.userSettingsService.userSettings["assistants"];
+    }
+    /**
+     * Get the instance ID of the chat service
+     * @returns The instance ID of the chat service
+     */
+    get chatInstanceId() {
+        return this._chatInstanceId;
+    }
+    /**
+     * Persist the instance ID of the chat service
+     * @param instanceId The instance ID of the chat service
+     */
+    setChatInstanceId(instanceId) {
+        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
+     * @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
+     * @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) {
+        this._chatId = chatId || guid();
+    }
+    /**
+     * 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.
+     * 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.
+     * The rest of the config object coming from "standard app config" is used as it is without any override.
+     * Thus, the user preferences are used only for the defaultValues object.
+     * 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)}`);
+        }
+    }
+    /**
+     * Update the chat config and store its defaultValues in the user preferences
+     * @param config  The updated chat config
+     * @param hashes  The updated hashes to store in the user preferences
+     * @param notify  Whether to notify the user about the update
+     * @param successCallback  The callback to execute if the update is successful
+     * @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 }));
+            }
+        });
+    }
+    /**
+     * 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.
+     * @param quota The updated quota
+     * @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);
+        }
+    }
+    /**
+     * A handler for chat usage metrics each time the generation of the assistant response is completed.
+     * It emits the chat usage metrics to the chatUsageMetrics$ subject, emits accordingly the updated chat's tokens consumption
+     * @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 });
+    }
+    /**
+     * Get the model description for the given (serviceId + modelId)
+     * If a model is not found, an error message is returned
+     * @param serviceId The serviceId of the model
+     * @param modelId The modelId of the model
+     * @returns The model description
+     */
+    getModel(serviceId, modelId) {
+        const model = this.models?.find(m => m.serviceId === serviceId && m.modelId === modelId);
+        // Handle obsolete config
+        if (!model) {
+            this.notificationsService.error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available. Please contact an admin for further information.`);
+            throw new Error(`FATAL ERROR : The model (serviceId = '${serviceId}', modelId = '${modelId}') is no longer available`);
+        }
+        return model;
+    }
+    /**
+     * 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
+     * @param details Audit event details
+     * @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
+     */
+    async generateAuditEvent(type, details, id) {
+        const baseDetails = {
+            "url": decodeURIComponent(window.location.href),
+            "app": this.appService.appName,
+            "user-id": this.principalService.principal?.userId,
+            "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
+        };
+        const audit = {
+            type,
+            detail: {
+                ...baseDetails,
+                ...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 || '';
+    }
+    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 }); }
+}
+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  /** 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"]}

package/esm2022/chat/debug-message/debug-message.component.mjs

@@ -0,0 +1,43 @@
+import { CommonModule } from "@angular/common";
+import { Component, Input } from "@angular/core";
+import * as Prism from 'prismjs';
+import { provideTranslocoScope, TranslocoPipe } from '@jsverse/transloco';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/ui.service";
+import * as i2 from "@angular/common";
+export class DebugMessageComponent {
+    constructor(ui) {
+        this.ui = ui;
+        this.level = 0; // Track the nesting level
+        this.parentColor = ''; // Track the parent row color
+    }
+    ngAfterViewInit() {
+        Prism.highlightAll();
+    }
+    isObject(value) {
+        return value !== null && typeof value === 'object';
+    }
+    getRowClass(item, index) {
+        if (item.isError)
+            return 'row-error';
+        if (this.level === 0)
+            return index % 2 === 0 ? 'row-even' : 'row-odd';
+        return this.parentColor;
+    }
+    copyToClipboard(code) {
+        this.ui.copyToClipboard(JSON.stringify(code, null, 2));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugMessageComponent, deps: [{ token: i1.UIService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DebugMessageComponent, isStandalone: true, selector: "sq-debug-message", inputs: { data: "data", level: "level", parentColor: "parentColor" }, providers: [provideTranslocoScope('chat-debug-message')], ngImport: i0, template: "<div *ngIf=\"data\" class=\"table-root\">\n  <ng-container *ngFor=\"let item of data; let i = index\">\n    <div *ngIf=\"item.type === 'KV'\" [ngClass]=\"getRowClass(item, i)\" class=\"d-flex w-100 kv-object\">\n      <div class=\"kv-key\">{{ item.data.key }}</div>\n      <div class=\"kv-value\">\n        <ng-container *ngIf=\"isObject(item.data.value); else normalValue\">\n          <div class=\"card mb-2\">\n            <div class=\"card-header\">\n              <button class=\"btn btn-light btn-sm\" (click)=\"copyToClipboard(item.data.value)\"><i class=\"far fa-fw fa-clipboard\"></i> {{ 'chatDebugMessage.copyCode' | transloco }}</button>\n            </div>\n            <pre class=\"language-json my-0 rounded-0 rounded-bottom\"><code class=\"language-json\">{{ item.data.value | json }}</code></pre>\n          </div>\n        </ng-container>\n        <ng-template #normalValue><div class=\"data-value\">{{ item.data.value }}</div></ng-template>\n      </div>\n    </div>\n    <div *ngIf=\"item.type === 'LIST'\" [ngClass]=\"getRowClass(item, i)\" class=\"d-flex w-100 list-object\">\n      <div class=\"list-name w-100\" [class.fw-bold]=\"level === 0\" (click)=\"item.expanded=!item.expanded\">\n        <i class=\"fas\" [class.fa-chevron-up]=\"item.expanded\" [class.fa-chevron-down]=\"!item.expanded\"></i>\n        {{ item.name }}\n      </div>\n      <div class=\"list-items w-100\" *ngIf=\"item.expanded\">\n        <sq-debug-message [data]=\"item.items\" [level]=\"level + 1\" [parentColor]=\"getRowClass(item, i)\"></sq-debug-message>\n      </div>\n    </div>\n  </ng-container>\n</div>\n", styles: [".table-root{display:flex;flex-direction:column;border:1px solid #ccc;width:100%;border-spacing:0}.table-row{display:flex;width:100%}.list-name{width:15%;cursor:pointer}.list-items{width:85%}.kv-key,.kv-value,.list-name{padding:8px;border:1px solid #ccc;box-sizing:border-box;word-wrap:break-word}.kv-key{width:20%}.kv-value{width:80%}.kv-value .data-value{white-space:pre-line}.kv-object,.list-object{display:flex;flex:1}.list-object{flex-direction:column}.row-even{background-color:#fff}.row-odd{background-color:#f2f8fe}.row-error{background-color:#f08080}.table-row:not(:last-child){border-bottom:1px solid #ccc}.kv-key:last-child,.kv-value:last-child,.list-name:last-child{border-right:none}.d-flex{display:flex}.w-100{width:100%}.card{--bs-card-spacer-y: 1rem;--bs-card-spacer-x: 1rem;--bs-card-title-spacer-y: .5rem;--bs-card-title-color: ;--bs-card-subtitle-color: ;--bs-card-border-width: var(--bs-border-width);--bs-card-border-color: var(--bs-border-color-translucent);--bs-card-border-radius: var(--bs-border-radius);--bs-card-box-shadow: ;--bs-card-inner-border-radius: calc(var(--bs-border-radius) - (var(--bs-border-width)));--bs-card-cap-padding-y: .5rem;--bs-card-cap-padding-x: 1rem;--bs-card-cap-bg: rgba(var(--bs-body-color-rgb), .03);--bs-card-cap-color: ;--bs-card-height: ;--bs-card-color: ;--bs-card-bg: var(--bs-body-bg);--bs-card-img-overlay-padding: 1rem;--bs-card-group-margin: .75rem;position:relative;display:flex;flex-direction:column;min-width:0;height:var(--bs-card-height);color:var(--bs-body-color);word-wrap:break-word;background-color:var(--bs-card-bg);background-clip:border-box;border:var(--bs-card-border-width) solid var(--bs-card-border-color);border-radius:var(--bs-card-border-radius)}.card-header{padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x);margin-bottom:0;color:var(--bs-card-cap-color);background-color:var(--bs-card-cap-bg);border-bottom:var(--bs-card-border-width) solid var(--bs-card-border-color)}.btn{--bs-btn-padding-x: .75rem;--bs-btn-padding-y: .375rem;--bs-btn-font-family: ;--bs-btn-font-size: 1rem;--bs-btn-font-weight: 400;--bs-btn-line-height: 1.5;--bs-btn-color: var(--bs-body-color);--bs-btn-bg: transparent;--bs-btn-border-width: var(--bs-border-width);--bs-btn-border-color: transparent;--bs-btn-border-radius: var(--bs-border-radius);--bs-btn-hover-border-color: transparent;--bs-btn-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);--bs-btn-disabled-opacity: .65;--bs-btn-focus-box-shadow: 0 0 0 .25rem rgba(var(--bs-btn-focus-shadow-rgb), .5);display:inline-block;padding:var(--bs-btn-padding-y) var(--bs-btn-padding-x);font-family:var(--bs-btn-font-family);font-size:var(--bs-btn-font-size);font-weight:var(--bs-btn-font-weight);line-height:var(--bs-btn-line-height);color:var(--bs-btn-color);text-align:center;text-decoration:none;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;border:var(--bs-btn-border-width) solid var(--bs-btn-border-color);border-radius:var(--bs-btn-border-radius);background-color:var(--bs-btn-bg);transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}.btn-light{--bs-btn-color: #000;--bs-btn-bg: #f8f9fa;--bs-btn-border-color: #f8f9fa;--bs-btn-hover-color: #000;--bs-btn-hover-bg: #d3d4d5;--bs-btn-hover-border-color: #c6c7c8;--bs-btn-focus-shadow-rgb: 211, 212, 213;--bs-btn-active-color: #000;--bs-btn-active-bg: #c6c7c8;--bs-btn-active-border-color: #babbbc;--bs-btn-active-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);--bs-btn-disabled-color: #000;--bs-btn-disabled-bg: #f8f9fa;--bs-btn-disabled-border-color: #f8f9fa}.btn-sm,.btn-group-sm>.btn{--bs-btn-padding-y: .25rem;--bs-btn-padding-x: .5rem;--bs-btn-font-size: .875rem;--bs-btn-border-radius: var(--bs-border-radius-sm)}.rounded-0{border-radius:0!important}.rounded-bottom{border-bottom-right-radius:var(--bs-border-radius)!important;border-bottom-left-radius:var(--bs-border-radius)!important}\n"], dependencies: [{ kind: "component", type: DebugMessageComponent, selector: "sq-debug-message", inputs: ["data", "level", "parentColor"] }, { kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.JsonPipe, name: "json" }, { kind: "pipe", type: TranslocoPipe, name: "transloco" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugMessageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "sq-debug-message", standalone: true, imports: [CommonModule, TranslocoPipe], providers: [provideTranslocoScope('chat-debug-message')], template: "<div *ngIf=\"data\" class=\"table-root\">\n  <ng-container *ngFor=\"let item of data; let i = index\">\n    <div *ngIf=\"item.type === 'KV'\" [ngClass]=\"getRowClass(item, i)\" class=\"d-flex w-100 kv-object\">\n      <div class=\"kv-key\">{{ item.data.key }}</div>\n      <div class=\"kv-value\">\n        <ng-container *ngIf=\"isObject(item.data.value); else normalValue\">\n          <div class=\"card mb-2\">\n            <div class=\"card-header\">\n              <button class=\"btn btn-light btn-sm\" (click)=\"copyToClipboard(item.data.value)\"><i class=\"far fa-fw fa-clipboard\"></i> {{ 'chatDebugMessage.copyCode' | transloco }}</button>\n            </div>\n            <pre class=\"language-json my-0 rounded-0 rounded-bottom\"><code class=\"language-json\">{{ item.data.value | json }}</code></pre>\n          </div>\n        </ng-container>\n        <ng-template #normalValue><div class=\"data-value\">{{ item.data.value }}</div></ng-template>\n      </div>\n    </div>\n    <div *ngIf=\"item.type === 'LIST'\" [ngClass]=\"getRowClass(item, i)\" class=\"d-flex w-100 list-object\">\n      <div class=\"list-name w-100\" [class.fw-bold]=\"level === 0\" (click)=\"item.expanded=!item.expanded\">\n        <i class=\"fas\" [class.fa-chevron-up]=\"item.expanded\" [class.fa-chevron-down]=\"!item.expanded\"></i>\n        {{ item.name }}\n      </div>\n      <div class=\"list-items w-100\" *ngIf=\"item.expanded\">\n        <sq-debug-message [data]=\"item.items\" [level]=\"level + 1\" [parentColor]=\"getRowClass(item, i)\"></sq-debug-message>\n      </div>\n    </div>\n  </ng-container>\n</div>\n", styles: [".table-root{display:flex;flex-direction:column;border:1px solid #ccc;width:100%;border-spacing:0}.table-row{display:flex;width:100%}.list-name{width:15%;cursor:pointer}.list-items{width:85%}.kv-key,.kv-value,.list-name{padding:8px;border:1px solid #ccc;box-sizing:border-box;word-wrap:break-word}.kv-key{width:20%}.kv-value{width:80%}.kv-value .data-value{white-space:pre-line}.kv-object,.list-object{display:flex;flex:1}.list-object{flex-direction:column}.row-even{background-color:#fff}.row-odd{background-color:#f2f8fe}.row-error{background-color:#f08080}.table-row:not(:last-child){border-bottom:1px solid #ccc}.kv-key:last-child,.kv-value:last-child,.list-name:last-child{border-right:none}.d-flex{display:flex}.w-100{width:100%}.card{--bs-card-spacer-y: 1rem;--bs-card-spacer-x: 1rem;--bs-card-title-spacer-y: .5rem;--bs-card-title-color: ;--bs-card-subtitle-color: ;--bs-card-border-width: var(--bs-border-width);--bs-card-border-color: var(--bs-border-color-translucent);--bs-card-border-radius: var(--bs-border-radius);--bs-card-box-shadow: ;--bs-card-inner-border-radius: calc(var(--bs-border-radius) - (var(--bs-border-width)));--bs-card-cap-padding-y: .5rem;--bs-card-cap-padding-x: 1rem;--bs-card-cap-bg: rgba(var(--bs-body-color-rgb), .03);--bs-card-cap-color: ;--bs-card-height: ;--bs-card-color: ;--bs-card-bg: var(--bs-body-bg);--bs-card-img-overlay-padding: 1rem;--bs-card-group-margin: .75rem;position:relative;display:flex;flex-direction:column;min-width:0;height:var(--bs-card-height);color:var(--bs-body-color);word-wrap:break-word;background-color:var(--bs-card-bg);background-clip:border-box;border:var(--bs-card-border-width) solid var(--bs-card-border-color);border-radius:var(--bs-card-border-radius)}.card-header{padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x);margin-bottom:0;color:var(--bs-card-cap-color);background-color:var(--bs-card-cap-bg);border-bottom:var(--bs-card-border-width) solid var(--bs-card-border-color)}.btn{--bs-btn-padding-x: .75rem;--bs-btn-padding-y: .375rem;--bs-btn-font-family: ;--bs-btn-font-size: 1rem;--bs-btn-font-weight: 400;--bs-btn-line-height: 1.5;--bs-btn-color: var(--bs-body-color);--bs-btn-bg: transparent;--bs-btn-border-width: var(--bs-border-width);--bs-btn-border-color: transparent;--bs-btn-border-radius: var(--bs-border-radius);--bs-btn-hover-border-color: transparent;--bs-btn-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);--bs-btn-disabled-opacity: .65;--bs-btn-focus-box-shadow: 0 0 0 .25rem rgba(var(--bs-btn-focus-shadow-rgb), .5);display:inline-block;padding:var(--bs-btn-padding-y) var(--bs-btn-padding-x);font-family:var(--bs-btn-font-family);font-size:var(--bs-btn-font-size);font-weight:var(--bs-btn-font-weight);line-height:var(--bs-btn-line-height);color:var(--bs-btn-color);text-align:center;text-decoration:none;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;border:var(--bs-btn-border-width) solid var(--bs-btn-border-color);border-radius:var(--bs-btn-border-radius);background-color:var(--bs-btn-bg);transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}.btn-light{--bs-btn-color: #000;--bs-btn-bg: #f8f9fa;--bs-btn-border-color: #f8f9fa;--bs-btn-hover-color: #000;--bs-btn-hover-bg: #d3d4d5;--bs-btn-hover-border-color: #c6c7c8;--bs-btn-focus-shadow-rgb: 211, 212, 213;--bs-btn-active-color: #000;--bs-btn-active-bg: #c6c7c8;--bs-btn-active-border-color: #babbbc;--bs-btn-active-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);--bs-btn-disabled-color: #000;--bs-btn-disabled-bg: #f8f9fa;--bs-btn-disabled-border-color: #f8f9fa}.btn-sm,.btn-group-sm>.btn{--bs-btn-padding-y: .25rem;--bs-btn-padding-x: .5rem;--bs-btn-font-size: .875rem;--bs-btn-border-radius: var(--bs-border-radius-sm)}.rounded-0{border-radius:0!important}.rounded-bottom{border-bottom-right-radius:var(--bs-border-radius)!important;border-bottom-left-radius:var(--bs-border-radius)!important}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UIService }], propDecorators: { data: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], parentColor: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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