@sinequa/assistant 3.1.1

package/esm2020/chat/websocket-chat.service.mjs

@@ -0,0 +1,430 @@
+import { Injectable, inject } from "@angular/core";
+import { AuthenticationService } from "@sinequa/core/login";
+import { SignalRWebService } from "@sinequa/core/web-services";
+import { HttpTransportType, LogLevel } from "@microsoft/signalr";
+import { ChatService } from "./chat.service";
+import { merge, fromEvent, Subject, catchError, filter, forkJoin, map, shareReplay, switchMap, tap, throwError, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+export class WebSocketChatService extends ChatService {
+    constructor() {
+        super();
+        this.connectionBuilt$ = new Subject(); // Emit when the connection is built
+        this.connectionStarted$ = new Subject(); // Emit when the connection is started
+        this.messageHandlers = new Map();
+        this.actionMap = new Map();
+        this.content = "";
+        this.attachments = [];
+        this.signalRService = inject(SignalRWebService);
+        this.authenticationService = inject(AuthenticationService);
+    }
+    /**
+     * Initialize the chat process after the login is complete.
+     * It includes building and starting a connection, executing parallel requests for models and functions, and handling errors during the process.
+     *
+     * @returns An Observable<boolean> indicating the success of the initialization process.
+     */
+    init() {
+        return this.loginService.events.pipe(filter((e) => e.type === 'login-complete'), tap(() => this.getRequestsUrl()), 
+        // Build the connection and handle the completion with the connectionBuilt$ subject
+        switchMap(() => this.buildConnection()), tap(() => {
+            this.initMessageHandlers();
+            this.connectionBuilt$.next();
+        }), 
+        // Start the connection and handle the completion with the connectionStarted$ subject
+        switchMap(() => this.startConnection()), 
+        // Execute parallel requests for models and functions
+        switchMap(() => {
+            this.connectionStarted$.next();
+            return forkJoin([
+                this.listModels(),
+                this.listFunctions()
+            ]);
+        }), 
+        // Map the results of parallel requests to a boolean indicating success
+        map(([models, functions]) => {
+            this.initProcess$.next(true);
+            return !!models && !!functions;
+        }), 
+        // 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);
+        }), 
+        // Cache and replay the emitted value for subsequent subscribers
+        shareReplay(1));
+    }
+    /**
+     * Define the assistant endpoint to use for the websocket requests
+     * It can be overridden by the app config
+     */
+    getRequestsUrl() {
+        if (this.chatConfig$.value.globalSettings.websocketEndpoint) {
+            this.REQUEST_URL = this.chatConfig$.value.globalSettings.websocketEndpoint;
+        }
+        else {
+            throw new Error(`The property 'websocketEndpoint' must be provided when attempting to use 'WebSocket' in assistant instance`);
+        }
+    }
+    listModels() {
+        const modelsSubject = new Subject();
+        this.connection.on('ListModels', (res) => {
+            this.models = res.models?.filter(model => !!model.enable);
+            modelsSubject.next(this.models);
+            modelsSubject.complete();
+        });
+        // Send the request to get the list of models
+        this.connection.invoke('ListModels', { debug: this.chatConfig$.value.debug })
+            .catch(error => {
+            console.error('Error invoking ListModels:', error);
+            modelsSubject.complete();
+            return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection
+        });
+        return modelsSubject.asObservable();
+    }
+    listFunctions() {
+        const functionsSubject = new Subject();
+        this.connection.on('ListFunctions', (res) => {
+            this.functions = res.functions;
+            functionsSubject.next(this.functions);
+            functionsSubject.complete();
+        });
+        // Send the request to get the list of functions
+        this.connection.invoke('ListFunctions', { debug: this.chatConfig$.value.debug })
+            .catch(error => {
+            console.error('Error invoking ListFunctions:', error);
+            functionsSubject.complete();
+            return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection
+        });
+        return functionsSubject.asObservable();
+    }
+    fetch(messages, query = this.searchService.query) {
+        // Start streaming by invoking the Chat method
+        this.streaming$.next(true);
+        // Prepare the payload to send to the Chat method
+        const data = {
+            history: messages,
+            functions: this.chatConfig$.value.functions,
+            debug: this.chatConfig$.value.debug,
+            serviceSettings: this.chatConfig$.value.serviceSettings,
+            contextSettings: {
+                ...this.chatConfig$.value.contextSettings,
+                app: this.appService.appName,
+                query
+            }
+        };
+        if (this.chatConfig$.value.saveChats) {
+            data.instanceId = this.chatInstanceId;
+            data.savedChatId = this.savedChatId;
+        }
+        let response = { role: "assistant", content: "", additionalProperties: { display: true } }; // here display: true is needed in order to be able to show the progress
+        // Create a Subject to signal completion
+        const completion$ = new Subject();
+        // Create observables for each non-global handler in the messageHandlers map (default and eventual custom ones) once it is triggered by the hub connection
+        const observables = Array
+            .from(this.messageHandlers.entries())
+            .filter(([eventName, eventHandler]) => !eventHandler.isGlobalHandler)
+            .map(([eventName, eventHandler]) => {
+            return fromEvent(this.connection, eventName).pipe(map((event) => eventHandler.handler(event)) // Execute the corresponding handler
+            );
+        });
+        // Then merge them into a single observable in order to simulate the streaming behavior
+        const combined$ = merge(...observables).pipe(takeUntil(completion$) // Complete the observable when completion$ emits
+        );
+        // Invoke the Chat method
+        this.connection.invoke('Chat', data)
+            .then(() => this.notifyAudit(this.chatHistory, this.chatConfig$.value.serviceSettings.service_id)) // When the server indicates it has successfully finished invoking the method, notify the audit service with the recent chat history
+            .catch(error => {
+            console.error('Error invoking Chat:', error);
+            return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection
+        })
+            .finally(() => {
+            this.streaming$.next(false); // Complete streaming regardless of success or error
+            this.actionMap.clear(); // Clear the actionMap
+            this.content = ""; // Clear the content
+            this.attachments = []; // Clear the attachments
+            this.executionTime = ""; // Clear the executionTime
+            completion$.next(); // Emit a signal to complete the observables
+            completion$.complete(); // Complete the subject
+        });
+        // Return the merged observables
+        return combined$.pipe(map(() => {
+            // Define $progress from the actionMap
+            const actions = Array.from(this.actionMap.values());
+            const $progress = actions.length > 0
+                ? actions.map((a) => ({
+                    title: a.displayName ?? "",
+                    content: a.displayValue ?? "",
+                    done: a.executionTime !== undefined,
+                    time: a.executionTime,
+                }))
+                : undefined;
+            // Define the attachment used in the context of the response message
+            const $attachment = this.attachments;
+            // As soon as the first content or $progress is defined, the assistant is considered as streaming
+            if (!!this.content || $progress || $attachment.length > 0) {
+                response = { ...response, content: this.content, additionalProperties: { ...response.additionalProperties, $progress, $attachment } };
+            }
+            // Return the result
+            return { history: [...messages, response], executionTime: this.executionTime };
+        }));
+    }
+    listSavedChat() {
+        const data = {
+            instanceId: this.chatInstanceId,
+            debug: this.chatConfig$.value.debug
+        };
+        this.connection.on('SavedChatList', (res) => {
+            this.savedChats$.next(res.savedChats); // emits the result to the savedChats$ subject
+        });
+        // Invoke the method SavedChatList
+        this.connection.invoke('SavedChatList', data)
+            .catch(error => {
+            console.error('Error invoking SavedChatList:', error);
+            return Promise.resolve();
+        });
+    }
+    getSavedChat(id) {
+        const savedChatSubject = new Subject();
+        const data = {
+            instanceId: this.chatInstanceId,
+            savedChatId: id,
+            debug: this.chatConfig$.value.debug
+        };
+        this.connection.on('SavedChatGet', (res) => {
+            savedChatSubject.next(res.savedChat);
+            savedChatSubject.complete();
+        });
+        // Invoke the method SavedChatGet
+        this.connection.invoke('SavedChatGet', data)
+            .catch(error => {
+            console.error('Error invoking SavedChatGet:', error);
+            savedChatSubject.complete();
+            return Promise.resolve();
+        });
+        return savedChatSubject.asObservable();
+    }
+    deleteSavedChat(ids) {
+        const deleteSavedChatSubject = new Subject();
+        const data = {
+            instanceId: this.chatInstanceId,
+            SavedChatIds: ids,
+            debug: this.chatConfig$.value.debug
+        };
+        this.connection.on('SavedChatDelete', (res) => {
+            deleteSavedChatSubject.next(res.deleteCount);
+            deleteSavedChatSubject.complete();
+        });
+        // Invoke the method SavedChatDelete
+        this.connection.invoke('SavedChatDelete', data)
+            .catch(error => {
+            console.error('Error invoking SavedChatDelete:', error);
+            deleteSavedChatSubject.complete();
+            return Promise.resolve();
+        });
+        return deleteSavedChatSubject.asObservable();
+    }
+    /**
+     * 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 a single message or a result
+     */
+    initMessageHandlers() {
+        this.addMessageHandler("Debug", { handler: (debug) => console.log(debug),
+            isGlobalHandler: true });
+        this.addMessageHandler("ActionStart", { handler: (action) => this.actionMap.set(action.guid, action),
+            isGlobalHandler: false });
+        this.addMessageHandler("ActionResult", {
+            handler: (action) => this.actionMap.set(action.guid, { ...this.actionMap.get(action.guid), ...action }),
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("ActionStop", {
+            handler: (action) => this.actionMap.set(action.guid, { ...this.actionMap.get(action.guid), ...action }),
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("ContextMessage", {
+            handler: (message) => this.attachments.push(message.metadata),
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("Message", {
+            handler: (message) => this.content += message ?? "",
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("History", {
+            handler: (history) => {
+                this.chatHistory = history.history;
+                this.executionTime = history.executionTime;
+            },
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("Error", {
+            handler: (error) => {
+                console.error(error);
+                this.notificationsService.error(error);
+            },
+            isGlobalHandler: true
+        });
+        this.addMessageHandler("Quota", {
+            handler: (message) => {
+                if (message.quota.maxQuotaReached) {
+                    const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${this.formatDateTime(message.quota.nextResetUTC)}.`;
+                    console.error(msg);
+                    this.notificationsService.error(msg);
+                }
+            },
+            isGlobalHandler: true
+        });
+    }
+    /**
+     * Override and register the entire messageHandlers map by merging the provided map with the default one
+     * @param messageHandlers
+     */
+    overrideMessageHandlers(messageHandlers) {
+        // Clear the already registered global chat handlers before merging the new ones
+        this.messageHandlers.forEach((eventHandler, eventName) => {
+            if (eventHandler.isGlobalHandler) {
+                this.unsubscribeMessageHandler(eventName);
+            }
+        });
+        // Merge the new event handlers with the existing ones
+        this.messageHandlers = new Map([...this.messageHandlers, ...messageHandlers]);
+        // Register the global chat handlers among the merged map
+        this.messageHandlers.forEach((eventHandler, eventName) => {
+            if (eventHandler.isGlobalHandler) {
+                this.registerMessageHandler(eventName, eventHandler);
+            }
+        });
+    }
+    /**
+     * Add a listener for a specific event.
+     * If a listener for this same event already exists, it will be overridden.
+     * If the listener has "isChatGlobalHandler" 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.messageHandlers.set(eventName, eventHandler);
+        if (eventHandler.isGlobalHandler) {
+            this.registerMessageHandler(eventName, eventHandler);
+        }
+    }
+    /**
+     * Dynamically register a listener for a specific event.
+     * If a listener for this event already exists, it will be overridden.
+     * @param eventName Name of the event to register a listener for
+     * @param eventHandler The handler to be called when the event is received
+     */
+    registerMessageHandler(eventName, eventHandler) {
+        if (!this.connection) {
+            console.log("No connection found to register the listener" + eventName);
+            return;
+        }
+        this.connection.on(eventName, (data) => {
+            eventHandler.handler(data);
+        });
+    }
+    /**
+     * 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.messageHandlers.delete(eventName);
+        this.unsubscribeMessageHandler(eventName);
+    }
+    /**
+     * Unsubscribe from receiving messages for a specific event from the SignalR hub.
+     * ALL its related listeners will be removed from hub connection
+     * This is needed to prevent accumulating old listeners when overriding the entire messageHandlers map
+     * @param eventName Name of the event
+     */
+    unsubscribeMessageHandler(eventName) {
+        this.connection.off(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 new Promise((resolve, reject) => {
+            if (!this.REQUEST_URL) {
+                reject(new Error("No endpoint provided to connect the websocket to"));
+                return;
+            }
+            const logLevel = this.getLogLevel();
+            this.connection = this.signalRService.buildConnection(this.REQUEST_URL, { ...this.defaultOptions, ...options }, logLevel);
+            resolve();
+        });
+    }
+    /**
+     * Start the connection
+     * @returns Promise that resolves when the connection is started
+     */
+    startConnection() {
+        return this.signalRService.startConnection(this.connection);
+    }
+    /**
+     * Stop the connection
+     * @returns Promise that resolves when the connection is stopped
+     */
+    stopConnection() {
+        return this.signalRService.stopConnection(this.connection);
+    }
+    getTransports() {
+        switch (this.chatConfig$.value?.globalSettings.signalRTransport) {
+            case "WebSockets":
+                return HttpTransportType.WebSockets;
+            case "ServerSentEvents":
+                return HttpTransportType.ServerSentEvents;
+            case "LongPolling":
+                return HttpTransportType.LongPolling;
+            default:
+                return HttpTransportType.None;
+        }
+    }
+    getLogLevel() {
+        switch (this.chatConfig$.value?.globalSettings.signalRLogLevel) {
+            case "Critical":
+                return LogLevel.Critical; // Log level for diagnostic messages that indicate a failure that will terminate the entire application.
+            case "Debug":
+                return LogLevel.Debug; // Log level for low severity diagnostic messages.
+            case "Error":
+                return LogLevel.Error; // Log level for diagnostic messages that indicate a failure in the current operation.
+            case "Information":
+                return LogLevel.Information; // Log level for informational diagnostic messages.
+            case "None":
+                return LogLevel.None; // The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted.
+            case "Trace":
+                return LogLevel.Trace; // Log level for very low severity diagnostic messages.
+            case "Warning":
+                return LogLevel.Warning; // Log level for diagnostic messages that indicate a non-fatal problem.
+            default:
+                return LogLevel.None; // The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted.
+        }
+    }
+    get defaultOptions() {
+        let headers = {
+            "sinequa-force-camel-case": "true",
+            "x-language": this.intlService.currentLocale.name,
+            "ui-language": this.intlService.currentLocale.name,
+        };
+        if (this.authenticationService.processedCredentials) {
+            headers = { ...headers, "sinequa-csrf-token": this.authenticationService.processedCredentials.data.csrfToken };
+        }
+        ;
+        // For the first GET request sent by signalR to start a WebSocket protocol,
+        // as far as we know, signalR only lets us tweak the request with this access token factory
+        // so we pass along the Sinequa CSRF token to pass the CSRF check..
+        return {
+            transport: this.getTransports(),
+            withCredentials: true,
+            headers,
+            accessTokenFactory: () => this.authenticationService.processedCredentials?.data?.csrfToken || ""
+        };
+    }
+}
+WebSocketChatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: WebSocketChatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WebSocketChatService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: WebSocketChatService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: WebSocketChatService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-chat.service.js","sourceRoot":"","sources":["../../../../projects/assistant/chat/websocket-chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\nimport { AuthenticationService } from \"@sinequa/core/login\";\nimport { ConnectionOptions, SignalRWebService } from \"@sinequa/core/web-services\";\nimport { HttpTransportType, HubConnection, LogLevel, MessageHeaders } from \"@microsoft/signalr\";\nimport { ActionMessage, ActionResultEvent, ActionStartEvent, ActionStopEvent, MessageEvent, ChatMessage, ChatPayload, ChatResponse, GllmFunction, GllmModelDescription, MessageHandler, HistoryEvent, ErrorEvent, QuotaEvent, ChatContextAttachment, ContextMessageEvent, SavedChatHistory } from \"./types\";\nimport { ChatService } from \"./chat.service\";\nimport { merge, fromEvent, Observable, Subject, catchError, filter, forkJoin, map, shareReplay, switchMap, tap, throwError, takeUntil } from \"rxjs\";\n\n@Injectable()\nexport class WebSocketChatService extends ChatService {\n\n  public connection: HubConnection | undefined;\n  public connectionBuilt$ = new Subject<void>(); // Emit when the connection is built\n  public connectionStarted$ = new Subject<void>(); // Emit when the connection is started\n\n  private messageHandlers: Map<string, MessageHandler<any>> = new Map();\n\n  private actionMap = new Map<string, ActionMessage>();\n  private content = \"\";\n  private executionTime: string;\n  private attachments: ChatContextAttachment[] = [];\n\n  public signalRService = inject(SignalRWebService);\n  public authenticationService = inject(AuthenticationService);\n\n  constructor() {\n    super();\n  }\n\n  /**\n   * Initialize the chat process after the login is complete.\n   * It includes building and starting a connection, executing parallel requests for models and functions, and handling errors during the process.\n   *\n   * @returns An Observable<boolean> indicating the success of the initialization process.\n   */\n  init(): Observable<boolean> {\n    return this.loginService.events.pipe(\n      filter((e) => e.type === 'login-complete'),\n      tap(() => this.getRequestsUrl()),\n      // Build the connection and handle the completion with the connectionBuilt$ subject\n      switchMap(() => this.buildConnection()),\n      tap(() => {\n        this.initMessageHandlers();\n        this.connectionBuilt$.next();\n      }),\n      // Start the connection and handle the completion with the connectionStarted$ subject\n      switchMap(() => this.startConnection()),\n      // Execute parallel requests for models and functions\n      switchMap(() => {\n        this.connectionStarted$.next();\n        return 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        this.initProcess$.next(true);\n        return !!models && !!functions\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      // Cache and replay the emitted value for subsequent subscribers\n      shareReplay(1)\n    );\n  }\n\n  /**\n   * Define the assistant endpoint to use for the websocket requests\n   * It can be overridden by the app config\n   */\n  getRequestsUrl() {\n    if (this.chatConfig$.value!.globalSettings.websocketEndpoint) {\n      this.REQUEST_URL = this.chatConfig$.value!.globalSettings.websocketEndpoint;\n    } else {\n      throw new Error(`The property 'websocketEndpoint' must be provided when attempting to use 'WebSocket' in assistant instance`);\n    }\n  }\n\n  listModels(): Observable<GllmModelDescription[] | undefined> {\n    const modelsSubject = new Subject<GllmModelDescription[] | undefined>();\n\n    this.connection!.on('ListModels', (res) => {\n      this.models = res.models?.filter(model => !!model.enable);\n      modelsSubject.next(this.models);\n      modelsSubject.complete()\n    });\n\n    // Send the request to get the list of models\n    this.connection!.invoke('ListModels', { debug: this.chatConfig$.value!.debug })\n      .catch(error => {\n        console.error('Error invoking ListModels:', error);\n        modelsSubject.complete()\n        return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection\n      })\n\n    return modelsSubject.asObservable();\n  }\n\n  listFunctions(): Observable<GllmFunction[] | undefined> {\n    const functionsSubject = new Subject<GllmFunction[] | undefined>();\n\n    this.connection!.on('ListFunctions', (res) => {\n      this.functions = res.functions;\n      functionsSubject.next(this.functions);\n      functionsSubject.complete()\n    });\n\n    // Send the request to get the list of functions\n    this.connection!.invoke('ListFunctions', { debug: this.chatConfig$.value!.debug })\n      .catch(error => {\n        console.error('Error invoking ListFunctions:', error);\n        functionsSubject.complete()\n        return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection\n      })\n\n    return functionsSubject.asObservable();\n  }\n\n  fetch(messages: ChatMessage[], query = this.searchService.query): Observable<ChatResponse> {\n    // Start streaming by invoking the Chat method\n    this.streaming$.next(true);\n\n    // Prepare the payload to send to the Chat method\n    const data: ChatPayload = {\n      history: messages,\n      functions: this.chatConfig$.value!.functions,\n      debug: this.chatConfig$.value!.debug,\n      serviceSettings: this.chatConfig$.value!.serviceSettings,\n      contextSettings: {\n        ...this.chatConfig$.value!.contextSettings,\n        app: this.appService.appName,\n        query\n      }\n    }\n    if (this.chatConfig$.value!.saveChats) {\n      data.instanceId = this.chatInstanceId;\n      data.savedChatId = this.savedChatId;\n    }\n\n    let response: ChatMessage = {role: \"assistant\", content: \"\", additionalProperties: {display: true}}; // here display: true is needed in order to be able to show the progress\n\n    // Create a Subject to signal completion\n    const completion$ = new Subject<void>();\n\n    // Create observables for each non-global handler in the messageHandlers map (default and eventual custom ones) once it is triggered by the hub connection\n    const observables = Array\n      .from(this.messageHandlers.entries())\n      .filter(([eventName, eventHandler]) => !eventHandler.isGlobalHandler)\n      .map(([eventName, eventHandler]) => {\n        return fromEvent<any>(this.connection!, eventName).pipe(\n          map((event) => eventHandler.handler(event)) // Execute the corresponding handler\n        );\n      });\n\n    // Then merge them into a single observable in order to simulate the streaming behavior\n    const combined$ = merge(...observables).pipe(\n      takeUntil(completion$) // Complete the observable when completion$ emits\n    );\n\n    // Invoke the Chat method\n    this.connection!.invoke('Chat', data)\n      .then(() => this.notifyAudit(this.chatHistory!, this.chatConfig$.value!.serviceSettings.service_id)) // When the server indicates it has successfully finished invoking the method, notify the audit service with the recent chat history\n      .catch(error => {\n        console.error('Error invoking Chat:', error);\n        return Promise.resolve(); // Return a resolved promise to handle the error and prevent unhandled promise rejection\n      })\n      .finally(() => {\n        this.streaming$.next(false); // Complete streaming regardless of success or error\n        this.actionMap.clear(); // Clear the actionMap\n        this.content = \"\"; // Clear the content\n        this.attachments = []; // Clear the attachments\n        this.executionTime = \"\"; // Clear the executionTime\n        completion$.next(); // Emit a signal to complete the observables\n        completion$.complete(); // Complete the subject\n      });\n\n    // Return the merged observables\n    return combined$.pipe(\n      map(() => {\n        // Define $progress from the actionMap\n        const actions = Array.from(this.actionMap.values());\n        const $progress = actions.length > 0\n                          ? actions.map((a) => ({\n                                title: a.displayName ?? \"\",\n                                content: a.displayValue ?? \"\",\n                                done: a.executionTime !== undefined,\n                                time: a.executionTime,\n                              }))\n                          : undefined;\n\n        // Define the attachment used in the context of the response message\n        const $attachment = this.attachments;\n\n        // As soon as the first content or $progress is defined, the assistant is considered as streaming\n        if(!!this.content || $progress || $attachment.length > 0) {\n          response = {...response, content: this.content, additionalProperties: {...response.additionalProperties, $progress, $attachment} };\n        }\n\n        // Return the result\n        return { history: [...messages, response], executionTime: this.executionTime };\n      })\n    );\n  }\n\n  listSavedChat(): void {\n    const data = {\n      instanceId: this.chatInstanceId,\n      debug: this.chatConfig$.value!.debug\n    };\n\n    this.connection!.on('SavedChatList', (res) => {\n      this.savedChats$.next(res.savedChats); // emits the result to the savedChats$ subject\n    });\n\n    // Invoke the method SavedChatList\n    this.connection!.invoke('SavedChatList', data)\n      .catch(error => {\n        console.error('Error invoking SavedChatList:', error);\n        return Promise.resolve();\n      });\n  }\n\n  getSavedChat(id: string): Observable<SavedChatHistory | undefined> {\n    const savedChatSubject = new Subject<SavedChatHistory | undefined>();\n\n    const data = {\n      instanceId: this.chatInstanceId,\n      savedChatId: id,\n      debug: this.chatConfig$.value!.debug\n    };\n\n    this.connection!.on('SavedChatGet', (res) => {\n      savedChatSubject.next(res.savedChat);\n      savedChatSubject.complete()\n    });\n\n    // Invoke the method SavedChatGet\n    this.connection!.invoke('SavedChatGet', data)\n      .catch(error => {\n        console.error('Error invoking SavedChatGet:', error);\n        savedChatSubject.complete()\n        return Promise.resolve();\n      })\n\n    return savedChatSubject.asObservable();\n  }\n\n  deleteSavedChat(ids: string[]): Observable<number> {\n    const deleteSavedChatSubject = new Subject<number>();\n\n    const data = {\n      instanceId: this.chatInstanceId,\n      SavedChatIds: ids,\n      debug: this.chatConfig$.value!.debug\n    };\n\n    this.connection!.on('SavedChatDelete', (res) => {\n      deleteSavedChatSubject.next(res.deleteCount);\n      deleteSavedChatSubject.complete();\n    });\n\n    // Invoke the method SavedChatDelete\n    this.connection!.invoke('SavedChatDelete', data)\n      .catch(error => {\n        console.error('Error invoking SavedChatDelete:', error);\n        deleteSavedChatSubject.complete();\n        return Promise.resolve();\n      })\n\n    return deleteSavedChatSubject.asObservable();\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 a single message or a result\n   */\n  initMessageHandlers() {\n    this.addMessageHandler(\n      \"Debug\",\n      { handler: (debug: any) => console.log(debug),\n        isGlobalHandler: true\n      }\n    );\n    this.addMessageHandler(\n      \"ActionStart\",\n      { handler: (action: ActionStartEvent) => this.actionMap.set(action.guid, action),\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"ActionResult\",\n      {\n        handler: (action: ActionResultEvent) => this.actionMap.set(action.guid, { ...this.actionMap.get(action.guid), ...action }),\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"ActionStop\",\n      {\n        handler: (action: ActionStopEvent) => this.actionMap.set(action.guid, { ...this.actionMap.get(action.guid), ...action }),\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"ContextMessage\",\n      {\n        handler: (message: ContextMessageEvent) => this.attachments.push(message.metadata),\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"Message\",\n      {\n        handler: (message: MessageEvent) => this.content += message ?? \"\",\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"History\",\n      {\n        handler: (history: HistoryEvent) => {\n          this.chatHistory = history.history\n          this.executionTime = history.executionTime;\n        },\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\n      \"Error\",\n      {\n        handler: (error: ErrorEvent) => {\n          console.error(error);\n          this.notificationsService.error(error);\n        },\n        isGlobalHandler: true\n      }\n    );\n    this.addMessageHandler(\n      \"Quota\",\n      {\n        handler: (message: QuotaEvent) => {\n          if(message.quota.maxQuotaReached) {\n            const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${this.formatDateTime(message.quota.nextResetUTC)}.`;\n            console.error(msg);\n            this.notificationsService.error(msg);\n          }\n        },\n        isGlobalHandler: true\n      }\n    );\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>>) {\n    // Clear the already registered global chat handlers before merging the new ones\n    this.messageHandlers.forEach((eventHandler, eventName) => {\n      if(eventHandler.isGlobalHandler) {\n        this.unsubscribeMessageHandler(eventName);\n      }\n    });\n\n    // Merge the new event handlers with the existing ones\n    this.messageHandlers = new Map([...this.messageHandlers, ...messageHandlers]);\n\n    // Register the global chat handlers among the merged map\n    this.messageHandlers.forEach((eventHandler, eventName) => {\n      if(eventHandler.isGlobalHandler) {\n        this.registerMessageHandler(eventName, eventHandler);\n      }\n    });\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 \"isChatGlobalHandler\" 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>) {\n    this.messageHandlers.set(eventName, eventHandler);\n    if(eventHandler.isGlobalHandler) {\n      this.registerMessageHandler(eventName, eventHandler);\n    }\n  }\n\n  /**\n   * Dynamically register a listener for a specific event.\n   * If a listener for this event already exists, it will be overridden.\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  protected registerMessageHandler<T>(eventName: string, eventHandler: MessageHandler<T>) {\n    if (!this.connection) {\n      console.log(\"No connection found to register the listener\" + eventName);\n      return;\n    }\n\n    this.connection.on(eventName, (data: T) => {\n      eventHandler.handler(data);\n    });\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) {\n    this.messageHandlers.delete(eventName);\n    this.unsubscribeMessageHandler(eventName);\n  }\n\n  /**\n   * Unsubscribe from receiving messages for a specific event from the SignalR hub.\n   * ALL its related listeners will be removed from hub connection\n   * This is needed to prevent accumulating old listeners when overriding the entire messageHandlers map\n   * @param eventName Name of the event\n   */\n  protected unsubscribeMessageHandler(eventName: string) {\n    this.connection!.off(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 new Promise<void>((resolve, reject) => {\n      if (!this.REQUEST_URL) {\n          reject(new Error(\"No endpoint provided to connect the websocket to\"));\n          return;\n      }\n      const logLevel = this.getLogLevel();\n      this.connection = this.signalRService.buildConnection(this.REQUEST_URL, {...this.defaultOptions, ...options}, logLevel);\n      resolve();\n    });\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.signalRService.startConnection(this.connection);\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.signalRService.stopConnection(this.connection);\n  }\n\n  private getTransports(): HttpTransportType {\n    switch (this.chatConfig$.value?.globalSettings.signalRTransport) {\n      case \"WebSockets\":\n        return HttpTransportType.WebSockets;\n      case \"ServerSentEvents\":\n        return HttpTransportType.ServerSentEvents;\n      case \"LongPolling\":\n        return HttpTransportType.LongPolling;\n      default:\n        return HttpTransportType.None;\n    }\n  }\n\n  private getLogLevel(): LogLevel {\n    switch (this.chatConfig$.value?.globalSettings.signalRLogLevel) {\n      case \"Critical\":\n        return LogLevel.Critical; // Log level for diagnostic messages that indicate a failure that will terminate the entire application.\n      case \"Debug\":\n        return LogLevel.Debug; // Log level for low severity diagnostic messages.\n      case \"Error\":\n        return LogLevel.Error; // Log level for diagnostic messages that indicate a failure in the current operation.\n      case \"Information\":\n        return LogLevel.Information; // Log level for informational diagnostic messages.\n      case \"None\":\n        return LogLevel.None; // The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted.\n      case \"Trace\":\n        return LogLevel.Trace; // Log level for very low severity diagnostic messages.\n      case \"Warning\":\n        return LogLevel.Warning; // Log level for diagnostic messages that indicate a non-fatal problem.\n      default:\n        return LogLevel.None; // The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted.\n    }\n  }\n\n  get defaultOptions(): ConnectionOptions {\n    let headers: MessageHeaders = {\n      \"sinequa-force-camel-case\": \"true\",\n      \"x-language\": this.intlService.currentLocale.name,\n      \"ui-language\": this.intlService.currentLocale.name,\n    };\n    if (this.authenticationService.processedCredentials) {\n      headers = {...headers, \"sinequa-csrf-token\": this.authenticationService.processedCredentials.data.csrfToken};\n    };\n    // For the first GET request sent by signalR to start a WebSocket protocol,\n    // as far as we know, signalR only lets us tweak the request with this access token factory\n    // so we pass along the Sinequa CSRF token to pass the CSRF check..\n    return {\n      transport: this.getTransports(),\n      withCredentials: true,\n      headers,\n      accessTokenFactory: () => this.authenticationService.processedCredentials?.data?.csrfToken || \"\"\n    }\n  }\n}\n"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,3 @@
+// We'd like to not have a primary entry point but ng-packagr requires one currently
+export const sinequaAssistantModule = undefined;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2Fzc2lzdGFudC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9GQUFvRjtBQUNwRixNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBXZSdkIGxpa2UgdG8gbm90IGhhdmUgYSBwcmltYXJ5IGVudHJ5IHBvaW50IGJ1dCBuZy1wYWNrYWdyIHJlcXVpcmVzIG9uZSBjdXJyZW50bHlcbmV4cG9ydCBjb25zdCBzaW5lcXVhQXNzaXN0YW50TW9kdWxlID0gdW5kZWZpbmVkO1xuIl19

package/esm2020/sinequa-assistant.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZXF1YS1hc3Npc3RhbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9hc3Npc3RhbnQvc2luZXF1YS1hc3Npc3RhbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==