@sinequa/assistant 3.9.2 → 3.9.4

package/esm2022/chat/services/assistant-ws-frames.service.mjs

@@ -0,0 +1,388 @@
+import { Injectable, inject } from '@angular/core';
+import { TranslocoService } from '@jsverse/transloco';
+import { Observable, Subject, fromEvent, merge, of, throwError } from 'rxjs';
+import { map, mergeMap, takeUntil, tap, take, switchMap, finalize } from 'rxjs/operators';
+import { guid } from "@sinequa/atomic";
+import { AppService } from './app.service';
+import { AssistantUtils } from '../utils/utils.service';
+import { NotificationsService } from './notification.service';
+import * as i0 from "@angular/core";
+export class AssistantWsFramesService {
+    constructor() {
+        this.appService = inject(AppService);
+        this.transloco = inject(TranslocoService);
+        this.assistantUtils = inject(AssistantUtils);
+        this.notificationsService = inject(NotificationsService);
+        this._messageHandlers = new Map();
+        this._actionMap = new Map();
+        this._progress = undefined;
+        this._attachments = [];
+        this._debugMessages = [];
+    }
+    init(context) {
+        this.context = context;
+    }
+    ensureInitialized() {
+        if (!this.context) {
+            throw new Error('AssistantWsFramesService not initialized. Call init() first.');
+        }
+    }
+    fetch(messages, query) {
+        this.ensureInitialized();
+        const context = this.context;
+        const assistantConfig = context.getAssistantConfig();
+        // Start streaming by invoking the Chat method
+        context.setStreamingStatus(true);
+        // Prepare the payload to send to the Chat method
+        const data = {
+            history: messages,
+            functions: assistantConfig.defaultValues.functions?.filter(func => func.enabled).map(func => func.name),
+            debug: assistantConfig.defaultValues.debug,
+            serviceSettings: {
+                service_id: assistantConfig.defaultValues.service_id,
+                model_id: assistantConfig.defaultValues.model_id,
+                top_p: assistantConfig.defaultValues.top_p,
+                temperature: assistantConfig.defaultValues.temperature,
+                max_tokens: assistantConfig.defaultValues.max_tokens,
+                ...assistantConfig.additionalServiceSettings
+            },
+            appQuery: {
+                app: this.appService.appName,
+                query
+            },
+            instanceId: context.getChatInstanceId(),
+            chatId: context.getChatId(),
+            genericChatErrorMessage: assistantConfig.globalSettings.genericChatErrorMessage ? this.transloco.translate(assistantConfig.globalSettings.genericChatErrorMessage) : ""
+        };
+        // Initialize the response with an empty assistant message
+        // here display: true is needed in order to be able to show the progress
+        // here messageId is needed but it is temporary and will be replaced by the correct messageId generated by the assistant when the message starts streaming
+        this._response = [{ role: "assistant", content: "", additionalProperties: { display: true, messageId: guid() } }];
+        // 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]) => fromEvent(context.getHubConnection(), eventName).pipe(mergeMap((event) => {
+            // Wrap the handler in a try-catch block to prevent the entire stream from failing if an error occurs in a single handler
+            try {
+                // Execute the handler and emit the result
+                // NB: here we could use [eventHandler.handler(event)] which behind the scenes mergeMap interprets this array as an observable sequence with one item, which it then emits
+                return of(eventHandler.handler(event));
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${eventName}:`, error);
+                // Use throwError to propagate the error downstream
+                return throwError(() => new Error(`Error in event handler for ${eventName}: ${error}`));
+            }
+        })));
+        // Then merge them into a single observable in order to simulate the streaming behavior
+        const combined$ = merge(...observables).pipe(map(() => {
+            // Define $progress from the _actionMap
+            const actions = Array.from(this._actionMap.values());
+            this._progress = actions.length > 0
+                ? actions.map((a) => ({
+                    title: a.displayName ?? "",
+                    content: a.displayValue ?? "",
+                    done: a.executionTime !== undefined,
+                    time: a.executionTime,
+                }))
+                : undefined;
+            // Always update ONLY the first assistant message of the _response with the new $progress, $attachment and $debug
+            // Assuming that the first assistant message is always visible since the hub does not send hidden messages by design
+            // So even if the first assistant message is hidden (display: false), the _response[0] will and should contain :
+            //  - $progress, $attachment and $debug
+            //  - the content of the first visible assistant message in the workflow
+            // This is mandatory in order to match the behavior of consecutive messages and maintain consistency with the chatHistory
+            if (!!this._progress || this._attachments.length > 0 || this._debugMessages.length > 0) {
+                this._response[0].additionalProperties.$progress = this._progress;
+                this._response[0].additionalProperties.$attachment = this._attachments;
+                this._response[0].additionalProperties.$debug = this._debugMessages;
+            }
+            // Return the result
+            return { history: [...messages, ...this._response], executionTime: this._executionTime, executionTimeMilliseconds: this._executionTimeMilliseconds };
+        }), 
+        // Complete the observable when completion$ emits
+        takeUntil(completion$));
+        // return a new Observable that emits the result of the combined stream and handles the eventual errors of the invocation of the Chat method
+        return new Observable(observer => {
+            // Subscribe to combined stream
+            combined$.subscribe({
+                next: (value) => observer.next(value),
+                error: (err) => observer.error(err)
+            });
+            // Invoke the Chat method and handle errors
+            context.getHubConnection().invoke('Chat', data)
+                .then(() => {
+                const chatHistory = context.getChatHistory();
+                // If a valid assistant message with (display: true) was found, update it
+                // and it should always the case
+                const index = this.assistantUtils.firstVisibleAssistantMessageIndex(chatHistory);
+                if (index !== -1) {
+                    chatHistory[index].additionalProperties.$progress = this._progress;
+                    chatHistory[index].additionalProperties.$attachment = this._attachments;
+                    chatHistory[index].additionalProperties.$debug = this._debugMessages;
+                    context.setChatHistory(chatHistory);
+                }
+                // Save/update the chat if savedChat enabled
+                if (assistantConfig.savedChatSettings.enabled && context.getChatHistory().some((msg) => msg.additionalProperties?.isUserInput === true)) {
+                    context.isExistingSavedChat(context.getChatId()).pipe(take(1), switchMap((exists) => exists
+                        ? context.updateSavedChat(context.getChatId(), undefined, context.getChatHistory())
+                        : context.addSavedChat(context.getChatId(), context.getChatHistory()).pipe(tap(() => context.listSavedChat()))), finalize(() => context.setStreamingStatus(false))).subscribe({
+                        next: () => { },
+                        error: (error) => observer.error(error),
+                        complete: () => observer.complete()
+                    });
+                }
+                else {
+                    context.setStreamingStatus(false);
+                    observer.complete();
+                }
+            })
+                .catch(error => {
+                console.error('Error invoking Chat:', error);
+                context.setStreamingStatus(false);
+                // Emit the error to the newly created observable
+                observer.error(error);
+                // Return a resolved promise to handle the error and prevent unhandled promise rejection
+                return Promise.resolve();
+            })
+                .finally(() => {
+                // This block concerns ONLY the completion of the "Chat" method invocation.
+                // This means the completion of the combined$ stream.
+                // It does not take into account the completion of the entire fetch method (the observable returned by fetch) and which depends on the completion of the save chat action if enabled
+                this._response = []; // Clear the _response
+                this._actionMap.clear(); // Clear the _actionMap
+                this._progress = undefined; // Clear the _progress
+                this._attachments = []; // Clear the _attachments
+                this._debugMessages = []; // Clear the _debugMessages
+                this._executionTime = ""; // Clear the _executionTime
+                this._executionTimeMilliseconds = undefined; // Clear the _executionTimeMilliseconds
+                completion$.next(); // Emit a signal to complete the observables
+                completion$.complete(); // Complete the subject
+            });
+        });
+    }
+    initMessageHandlers() {
+        this.ensureInitialized();
+        const context = this.context;
+        this.addMessageHandler("Error", {
+            handler: (error) => {
+                if (error.indexOf('SavedChatList') !== -1) {
+                    context.setSavedChatsErrorStatus(true);
+                }
+                console.error(error);
+                this.notificationsService.error(error);
+            },
+            isGlobalHandler: true
+        });
+        this.addMessageHandler("Quota", {
+            handler: (message) => {
+                try {
+                    context.updateQuota(message.quota);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            },
+            isGlobalHandler: true
+        });
+        this.addMessageHandler("Debug", { handler: () => { }, 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.additionalProperties); },
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("Message", {
+            handler: (message) => {
+                this._response.at(-1).content += message.delta ?? "";
+                this._response.at(-1).additionalProperties.messageId = message.messageId;
+            },
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("History", {
+            handler: (history) => {
+                // The ChatHistory is updated: it is the current copy concatenated with the new items ONLY (it can have multiple messages: the context messages + the response message)
+                // This is mandatory to not lose the previous updates of the chatHistory when the assistant is streaming multiple message steps
+                const currentChatHistory = (context.getChatHistory() || []);
+                const newHistory = [...currentChatHistory, ...(history.history.slice(currentChatHistory.length))];
+                context.setChatHistory(newHistory);
+                // Emit the updated chat usage metrics
+                const lastMessage = newHistory.at(-1);
+                if (lastMessage?.additionalProperties.usageMetrics) {
+                    context.updateChatUsageMetrics(lastMessage.additionalProperties.usageMetrics);
+                }
+                this._executionTime = history.executionTime;
+                this._executionTimeMilliseconds = history.executionTimeMilliseconds;
+            },
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("SuggestedActions", {
+            handler: (message) => {
+                // Since after the "History" and "MessageBreak" that this event is caught,
+                // $suggestedAction needs to be updated directly to the last visible "assistant" message in the _response and the chatHistory
+                this._response.at(-1).additionalProperties.$suggestedAction = (this._response.at(-1).additionalProperties.$suggestedAction || []).concat(message.suggestedActions);
+                const chatHistory = context.getChatHistory();
+                const index = this.assistantUtils.lastVisibleAssistantMessageIndex(chatHistory);
+                if (index !== -1) {
+                    chatHistory[index].additionalProperties.$suggestedAction = (chatHistory[index].additionalProperties.$suggestedAction || []).concat(message.suggestedActions);
+                    context.setChatHistory(chatHistory);
+                }
+            },
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("DebugDisplay", {
+            handler: (message) => this._debugMessages = this._debugMessages.concat(message),
+            isGlobalHandler: false
+        });
+        this.addMessageHandler("MessageBreak", {
+            handler: () => {
+                // Systematically happens right after the "History" event
+                // This is the moment when the assistant message is fully streamed
+                const assistantConfig = context.getAssistantConfig();
+                const chatHistory = context.getChatHistory();
+                if (!assistantConfig || !chatHistory || !chatHistory.length)
+                    return;
+                const lastChatMessage = chatHistory.at(-1);
+                const details = {
+                    'duration': this._executionTimeMilliseconds !== undefined ? this._executionTimeMilliseconds : this._executionTime,
+                    'role': lastChatMessage.role,
+                    'rank': chatHistory.length,
+                    'message-id': lastChatMessage.additionalProperties.messageId,
+                    'generation-tokencount': lastChatMessage.additionalProperties.usageMetrics?.completionTokenCount,
+                    'prompt-tokencount': lastChatMessage.additionalProperties.usageMetrics?.promptTokenCount,
+                    'attachments': JSON.stringify(this._attachments.map(({ recordId, contextId, parts, type }) => ({
+                        recordId,
+                        contextId,
+                        parts: parts.map(({ partId, text }) => {
+                            if (!!assistantConfig.auditSettings?.logContent)
+                                return { partId, text };
+                            return { partId };
+                        }),
+                        type
+                    })))
+                };
+                if (!!assistantConfig.auditSettings?.logContent) {
+                    if (typeof lastChatMessage.content === 'string') {
+                        details['text'] = lastChatMessage.content;
+                    }
+                    else if (Array.isArray(lastChatMessage.content)) {
+                        details['text'] = lastChatMessage.content.find((msg) => msg.type === "text").text;
+                    }
+                }
+                context.generateAuditEvent('ast-message.message', details);
+                // Push a new assistant message to the _response array ONLY if the content of the last message is not empty
+                if (this._response.at(-1).content !== "") {
+                    this._response.push({ role: "assistant", content: "", additionalProperties: { display: true, messageId: guid() } });
+                }
+            },
+            isGlobalHandler: false
+        });
+    }
+    overrideMessageHandlers(_messageHandlers) {
+        this.ensureInitialized();
+        // 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 handlers among the merged map
+        this._messageHandlers.forEach((eventHandler, eventName) => {
+            if (eventHandler.isGlobalHandler) {
+                this.registerMessageHandler(eventName, eventHandler);
+            }
+        });
+    }
+    addMessageHandler(eventName, eventHandler) {
+        this.ensureInitialized();
+        this._messageHandlers.set(eventName, eventHandler);
+        if (eventHandler.isGlobalHandler) {
+            this.registerMessageHandler(eventName, eventHandler);
+        }
+    }
+    registerMessageHandler(eventName, eventHandler) {
+        this.ensureInitialized();
+        const connection = this.context.getHubConnection();
+        if (!connection) {
+            console.log("No connection found to register the listener" + eventName);
+            return;
+        }
+        connection.on(eventName, (data) => {
+            eventHandler.handler(data);
+        });
+    }
+    removeMessageHandler(eventName) {
+        this.ensureInitialized();
+        this._messageHandlers.delete(eventName);
+        this.unsubscribeMessageHandler(eventName);
+    }
+    unsubscribeMessageHandler(eventName) {
+        this.ensureInitialized();
+        const connection = this.context.getHubConnection();
+        connection?.off(eventName);
+    }
+    stopGeneration() {
+        this.ensureInitialized();
+        const context = this.context;
+        const connection = context.getHubConnection();
+        // Start stopping generation by invoking the CancelTasks method
+        context.setStoppingGenerationStatus(true);
+        // Create a Subject to hold the result of the CancelTasks method
+        const stopGenerationSubject$ = new Subject();
+        connection.on('CancelTasks', (res) => {
+            // When the generation is stopped before streaming any VISIBLE assistant message, this means that $progress, $attachment and $debug properties will be lost.
+            // However, the "ContextMessage" frames will be persisted in the chatHistory and the assistant may reference them in the next generation.
+            // This leads to the problem of referencing undisplayed attachments in the next generation.
+            // To solve this problem, we need to persist $progress, $attachment and $debug properties by adding a new assistant message with empty content and these properties.
+            // In the other hand, this leads to the problem of having many empty assistant messages in the chat history, if a stop generation happens multiple times in a row with no content generated yet.
+            // To solve this problem mentioned in the ticket ES-27024, we need to allow such operation ONLY if the last assistant message's content in the chat history is not empty.
+            const chatHistory = context.getChatHistory();
+            const isLastChatHistoryMessageAssistantContentEmpty = chatHistory?.length
+                && chatHistory.at(-1)?.role === "assistant"
+                && (chatHistory.at(-1)?.content === ""
+                    ||
+                        chatHistory.at(-1)?.content?.find((msg) => msg.type === "text")?.text === "");
+            if (this._response && this._response.length === 1 && this._response[0].content === "" && !isLastChatHistoryMessageAssistantContentEmpty) {
+                const newChatHistory = chatHistory ? [...chatHistory] : [];
+                newChatHistory.push({ role: "assistant", content: "", additionalProperties: { display: true, messageId: guid(), $progress: this._progress, $attachment: this._attachments, $debug: this._debugMessages } });
+                context.setChatHistory(newChatHistory);
+            }
+            // Emit the result of the CancelTasks method
+            stopGenerationSubject$.next(!!res);
+            // Complete the subject
+            stopGenerationSubject$.complete();
+            // Complete stopping generation
+            context.setStoppingGenerationStatus(false);
+        });
+        // Invoke the CancelTasks method and handle errors
+        connection.invoke('CancelTasks')
+            .catch(error => {
+            console.error('Error invoking CancelTasks:', error);
+            stopGenerationSubject$.error(new Error(error));
+            context.setStoppingGenerationStatus(false);
+            return Promise.resolve();
+        });
+        return stopGenerationSubject$.asObservable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AssistantWsFramesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AssistantWsFramesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AssistantWsFramesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assistant-ws-frames.service.js","sourceRoot":"","sources":["../../../../../projects/assistant/chat/services/assistant-ws-frames.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HubConnection } from '@microsoft/signalr';\nimport { TranslocoService } from '@jsverse/transloco';\nimport { Observable, Subject, fromEvent, merge, of, throwError } from 'rxjs';\nimport { map, mergeMap, takeUntil, tap, take, switchMap, finalize } from 'rxjs/operators';\n\nimport { guid, Query } from \"@sinequa/atomic\";\n\nimport {\n  ActionMessage,\n  ActionResultEvent,\n  ActionStartEvent,\n  ActionStopEvent,\n  ChatConfig,\n  ChatContextAttachment,\n  ChatMessage,\n  ChatPayload,\n  ChatProgress,\n  ChatResponse,\n  ChatUsageMetrics,\n  ContextMessageEvent,\n  DebugMessage,\n  DebugMessageEvent,\n  ErrorEvent,\n  HistoryEvent,\n  MessageHandler,\n  MessageEvent,\n  Quota,\n  QuotaEvent,\n  SavedChatResponse,\n  SuggestedActionsEvent\n} from '../types';\n\nimport { AppService } from './app.service';\nimport { AssistantUtils } from '../utils/utils.service';\nimport { NotificationsService } from './notification.service';\nimport { MessageContent, TextMessageContent } from '../types/message-content.types';\n\nexport interface AssistantWsFramesContext {\n  getAssistantConfig: () => ChatConfig | undefined;\n  getChatInstanceId: () => string;\n  getChatId: () => string;\n  getHubConnection: () => HubConnection | undefined;\n  getChatHistory: () => ChatMessage[] | undefined;\n\n  setStreamingStatus: (isStreaming: boolean) => void;\n  setChatHistory: (history: ChatMessage[] | undefined) => void;\n  setStoppingGenerationStatus: (isStopping: boolean) => void;\n  setSavedChatsErrorStatus: (hasError: boolean) => void;\n\n  updateQuota: (quota: Quota, propagateError?: boolean) => void;\n  updateChatUsageMetrics: (metrics: ChatUsageMetrics) => void;\n  generateAuditEvent: (type: string, details: Record<string, any>, id?: string) => Promise<void>;\n  addSavedChat: (id: string, messages: ChatMessage[]) => Observable<SavedChatResponse>;\n  updateSavedChat: (id: string, name?: string, messages?: ChatMessage[]) => Observable<SavedChatResponse>;\n  listSavedChat: () => void;\n  isExistingSavedChat: (id: string) => Observable<boolean>;\n}\n\n@Injectable()\nexport class AssistantWsFramesService {\n  private context: AssistantWsFramesContext | undefined;\n\n  private appService = inject(AppService);\n  private transloco = inject(TranslocoService);\n  private assistantUtils = inject(AssistantUtils);\n  private notificationsService = inject(NotificationsService);\n\n  private _messageHandlers: Map<string, MessageHandler<any>> = new Map();\n  private _response: ChatMessage[];\n  private _actionMap = new Map<string, ActionMessage>();\n  private _progress: ChatProgress[] | undefined = undefined;\n  private _executionTime: string;\n  private _executionTimeMilliseconds?: number;\n  private _attachments: ChatContextAttachment[] = [];\n  private _debugMessages: DebugMessage[] = [];\n\n  public init(context: AssistantWsFramesContext): void {\n    this.context = context;\n  }\n\n  private ensureInitialized(): void {\n    if (!this.context) {\n      throw new Error('AssistantWsFramesService not initialized. Call init() first.');\n    }\n  }\n\n  public fetch(messages: ChatMessage[], query: Query): Observable<ChatResponse> {\n    this.ensureInitialized();\n    const context = this.context!;\n    const assistantConfig = context.getAssistantConfig()!;\n\n     // Start streaming by invoking the Chat method\n    context.setStreamingStatus(true);\n\n    // Prepare the payload to send to the Chat method\n    const data: ChatPayload = {\n      history: messages,\n      functions: assistantConfig.defaultValues.functions?.filter(func => func.enabled).map(func => func.name),\n      debug: assistantConfig.defaultValues.debug,\n      serviceSettings: {\n        service_id: assistantConfig.defaultValues.service_id,\n        model_id: assistantConfig.defaultValues.model_id,\n        top_p: assistantConfig.defaultValues.top_p,\n        temperature: assistantConfig.defaultValues.temperature,\n        max_tokens: assistantConfig.defaultValues.max_tokens,\n        ...assistantConfig.additionalServiceSettings\n      },\n      appQuery: {\n        app: this.appService.appName,\n        query\n      },\n      instanceId: context.getChatInstanceId(),\n      chatId: context.getChatId(),\n      genericChatErrorMessage: assistantConfig.globalSettings.genericChatErrorMessage ? this.transloco.translate(assistantConfig.globalSettings.genericChatErrorMessage) : \"\"\n    };\n\n    // Initialize the response with an empty assistant message\n    // here display: true is needed in order to be able to show the progress\n    // here messageId is needed but it is temporary and will be replaced by the correct messageId generated by the assistant when the message starts streaming\n    this._response = [{ role: \"assistant\", content: \"\", additionalProperties: { display: true, messageId: guid() } }];\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]) => fromEvent<any>(context.getHubConnection()!, eventName).pipe(\n          mergeMap((event) => {\n            // Wrap the handler in a try-catch block to prevent the entire stream from failing if an error occurs in a single handler\n            try {\n              // Execute the handler and emit the result\n              // NB: here we could use [eventHandler.handler(event)] which behind the scenes mergeMap interprets this array as an observable sequence with one item, which it then emits\n              return of(eventHandler.handler(event));\n            } catch (error) {\n              console.error(`Error in event handler for ${eventName}:`, error);\n              // Use throwError to propagate the error downstream\n              return throwError(() => new Error(`Error in event handler for ${eventName}: ${error}`));\n            }\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      map(() => {\n        // Define $progress from the _actionMap\n        const actions = Array.from(this._actionMap.values());\n        this._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        // Always update ONLY the first assistant message of the _response with the new $progress, $attachment and $debug\n        // Assuming that the first assistant message is always visible since the hub does not send hidden messages by design\n        // So even if the first assistant message is hidden (display: false), the _response[0] will and should contain :\n        //  - $progress, $attachment and $debug\n        //  - the content of the first visible assistant message in the workflow\n        // This is mandatory in order to match the behavior of consecutive messages and maintain consistency with the chatHistory\n        if(!!this._progress || this._attachments.length > 0 || this._debugMessages.length > 0) {\n          this._response[0].additionalProperties.$progress = this._progress;\n          this._response[0].additionalProperties.$attachment = this._attachments;\n          this._response[0].additionalProperties.$debug = this._debugMessages;\n        }\n        // Return the result\n        return { history: [...messages, ...this._response], executionTime: this._executionTime, executionTimeMilliseconds: this._executionTimeMilliseconds };\n      }),\n      // Complete the observable when completion$ emits\n      takeUntil(completion$),\n    );\n\n    // return a new Observable that emits the result of the combined stream and handles the eventual errors of the invocation of the Chat method\n    return new Observable(observer => {\n      // Subscribe to combined stream\n      combined$.subscribe({\n        next: (value) => observer.next(value),\n        error: (err) => observer.error(err)\n      });\n\n      // Invoke the Chat method and handle errors\n      context.getHubConnection()!.invoke('Chat', data)\n        .then(() => {\n          const chatHistory = context.getChatHistory()!;\n          // If a valid assistant message with (display: true) was found, update it\n          // and it should always the case\n          const index = this.assistantUtils.firstVisibleAssistantMessageIndex(chatHistory);\n          if (index !== -1) {\n            chatHistory[index].additionalProperties.$progress = this._progress;\n            chatHistory[index].additionalProperties.$attachment = this._attachments;\n            chatHistory[index].additionalProperties.$debug = this._debugMessages;\n            context.setChatHistory(chatHistory);\n          }\n\n          // Save/update the chat if savedChat enabled\n          if (assistantConfig.savedChatSettings.enabled && context.getChatHistory()!.some((msg) => msg.additionalProperties?.isUserInput === true)) {\n            context.isExistingSavedChat(context.getChatId()).pipe(\n              take(1),\n              switchMap((exists) =>\n                exists\n                  ? context.updateSavedChat(context.getChatId(), undefined, context.getChatHistory()!)\n                  : context.addSavedChat(context.getChatId(), context.getChatHistory()!).pipe(\n                      tap(() => context.listSavedChat())\n                    )\n              ),\n              finalize(() => context.setStreamingStatus(false))\n            ).subscribe({\n              next: () => {},\n              error: (error) => observer.error(error),\n              complete: () => observer.complete()\n            });\n          } else {\n            context.setStreamingStatus(false);\n            observer.complete();\n          }\n        })\n        .catch(error => {\n          console.error('Error invoking Chat:', error);\n          context.setStreamingStatus(false);\n          // Emit the error to the newly created observable\n          observer.error(error);\n          // Return a resolved promise to handle the error and prevent unhandled promise rejection\n          return Promise.resolve();\n        })\n        .finally(() => {\n          // This block concerns ONLY the completion of the \"Chat\" method invocation.\n          // This means the completion of the combined$ stream.\n          // It does not take into account the completion of the entire fetch method (the observable returned by fetch) and which depends on the completion of the save chat action if enabled\n          this._response = []; // Clear the _response\n          this._actionMap.clear(); // Clear the _actionMap\n          this._progress = undefined; // Clear the _progress\n          this._attachments = []; // Clear the _attachments\n          this._debugMessages = []; // Clear the _debugMessages\n          this._executionTime = \"\"; // Clear the _executionTime\n          this._executionTimeMilliseconds = undefined; // Clear the _executionTimeMilliseconds\n          completion$.next(); // Emit a signal to complete the observables\n          completion$.complete(); // Complete the subject\n        });\n    });\n  }\n\n  public initMessageHandlers(): void {\n    this.ensureInitialized();\n    const context = this.context!;\n\n    this.addMessageHandler(\"Error\", {\n        handler: (error: ErrorEvent) => {\n          if (error.indexOf('SavedChatList') !== -1) {\n            context.setSavedChatsErrorStatus(true);\n          }\n          console.error(error);\n          this.notificationsService.error(error);\n        },\n        isGlobalHandler: true\n      }\n    );\n    this.addMessageHandler(\"Quota\", {\n        handler: (message: QuotaEvent) => {\n          try {\n            context.updateQuota(message.quota);\n          } catch (error) {\n            console.error(error);\n          }\n        },\n        isGlobalHandler: true\n      }\n    );\n    this.addMessageHandler(\"Debug\", { handler: () => {}, isGlobalHandler: true });\n    this.addMessageHandler(\"ActionStart\", {\n      handler: (action: ActionStartEvent) => this._actionMap.set(action.guid, action),\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"ActionResult\", {\n      handler: (action: ActionResultEvent) => this._actionMap.set(action.guid, { ...this._actionMap.get(action.guid), ...action }),\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"ActionStop\", {\n      handler: (action: ActionStopEvent) => this._actionMap.set(action.guid, { ...this._actionMap.get(action.guid), ...action }),\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"ContextMessage\", {\n      handler: (message: ContextMessageEvent) => { this._attachments.push(message.additionalProperties); },\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"Message\", {\n      handler: (message: MessageEvent) => {\n        this._response.at(-1)!.content += message.delta ?? \"\";\n        this._response.at(-1)!.additionalProperties.messageId = message.messageId;\n      },\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"History\", {\n        handler: (history: HistoryEvent) => {\n          // The ChatHistory is updated: it is the current copy concatenated with the new items ONLY (it can have multiple messages: the context messages + the response message)\n          // This is mandatory to not lose the previous updates of the chatHistory when the assistant is streaming multiple message steps\n          const currentChatHistory = (context.getChatHistory() || []) as ChatMessage[];\n          const newHistory = [...currentChatHistory, ...(history.history.slice(currentChatHistory.length))] as ChatMessage[];\n          context.setChatHistory(newHistory);\n\n          // Emit the updated chat usage metrics\n          const lastMessage = newHistory.at(-1);\n          if (lastMessage?.additionalProperties.usageMetrics) {\n            context.updateChatUsageMetrics(lastMessage.additionalProperties.usageMetrics);\n          }\n          this._executionTime = history.executionTime;\n          this._executionTimeMilliseconds = history.executionTimeMilliseconds;\n        },\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\"SuggestedActions\", {\n        handler: (message: SuggestedActionsEvent) => {\n          // Since after the \"History\" and \"MessageBreak\" that this event is caught,\n          // $suggestedAction needs to be updated directly to the last visible \"assistant\" message in the _response and the chatHistory\n          this._response.at(-1)!.additionalProperties.$suggestedAction = (this._response.at(-1)!.additionalProperties.$suggestedAction || []).concat(message.suggestedActions);\n          const chatHistory = context.getChatHistory()!;\n          const index = this.assistantUtils.lastVisibleAssistantMessageIndex(chatHistory);\n          if (index !== -1) {\n            chatHistory[index].additionalProperties.$suggestedAction = (chatHistory[index].additionalProperties.$suggestedAction || []).concat(message.suggestedActions);\n            context.setChatHistory(chatHistory);\n          }\n        },\n        isGlobalHandler: false\n      }\n    );\n    this.addMessageHandler(\"DebugDisplay\", {\n      handler: (message: DebugMessageEvent) => this._debugMessages = this._debugMessages.concat(message),\n      isGlobalHandler: false\n    });\n    this.addMessageHandler(\"MessageBreak\", {\n        handler: () => {\n          // Systematically happens right after the \"History\" event\n          // This is the moment when the assistant message is fully streamed\n          const assistantConfig = context.getAssistantConfig();\n          const chatHistory = context.getChatHistory();\n          if (!assistantConfig || !chatHistory || !chatHistory.length) return;\n\n          const lastChatMessage = chatHistory.at(-1)!;\n\n          const details = {\n            'duration': this._executionTimeMilliseconds !== undefined ? this._executionTimeMilliseconds : this._executionTime,\n            'role': lastChatMessage.role,\n            'rank': chatHistory.length,\n            'message-id': lastChatMessage.additionalProperties.messageId,\n            'generation-tokencount': lastChatMessage.additionalProperties.usageMetrics?.completionTokenCount,\n            'prompt-tokencount': lastChatMessage.additionalProperties.usageMetrics?.promptTokenCount,\n            'attachments': JSON.stringify(this._attachments.map(({ recordId, contextId, parts, type }) => ({\n                            recordId,\n                            contextId,\n                            parts: parts.map(({ partId, text }) => {\n                              if (!!assistantConfig.auditSettings?.logContent) return { partId, text };\n                              return { partId };\n                            }),\n                            type\n                          })))\n          };\n          if (!!assistantConfig.auditSettings?.logContent) {\n            if (typeof lastChatMessage.content === 'string') {\n              (details as any)['text'] = lastChatMessage.content;\n            } else if (Array.isArray(lastChatMessage.content)) {\n              (details as any)['text'] = (lastChatMessage.content.find((msg) => msg.type === \"text\") as TextMessageContent).text\n            }\n          }\n          context.generateAuditEvent('ast-message.message', details);\n          // Push a new assistant message to the _response array ONLY if the content of the last message is not empty\n          if (this._response.at(-1)!.content !== \"\") {\n            this._response.push({role: \"assistant\", content: \"\", additionalProperties: {display: true, messageId: guid()}});\n          }\n        },\n        isGlobalHandler: false\n      }\n    );\n  }\n\n  public overrideMessageHandlers<T>(_messageHandlers: Map<string, MessageHandler<T>>): void {\n    this.ensureInitialized();\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    // Merge the new event handlers with the existing ones\n    this._messageHandlers = new Map([...this._messageHandlers, ..._messageHandlers]);\n    // Register the global 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  public addMessageHandler<T>(eventName: string, eventHandler: MessageHandler<T>): void {\n    this.ensureInitialized();\n    this._messageHandlers.set(eventName, eventHandler);\n    if(eventHandler.isGlobalHandler) {\n      this.registerMessageHandler(eventName, eventHandler);\n    }\n  }\n\n  public registerMessageHandler<T>(eventName: string, eventHandler: MessageHandler<T>): void {\n    this.ensureInitialized();\n    const connection = this.context!.getHubConnection();\n    if (!connection) {\n      console.log(\"No connection found to register the listener\" + eventName);\n      return;\n    }\n    connection.on(eventName, (data: T) => {\n      eventHandler.handler(data);\n    });\n  }\n\n  public removeMessageHandler(eventName: string): void {\n    this.ensureInitialized();\n    this._messageHandlers.delete(eventName);\n    this.unsubscribeMessageHandler(eventName);\n  }\n\n  public unsubscribeMessageHandler(eventName: string): void {\n    this.ensureInitialized();\n    const connection = this.context!.getHubConnection();\n    connection?.off(eventName);\n  }\n\n  public stopGeneration(): Observable<boolean> {\n    this.ensureInitialized();\n    const context = this.context!;\n    const connection = context.getHubConnection()!;\n\n     // Start stopping generation by invoking the CancelTasks method\n    context.setStoppingGenerationStatus(true);\n    // Create a Subject to hold the result of the CancelTasks method\n    const stopGenerationSubject$ = new Subject<boolean>();\n\n    connection.on('CancelTasks', (res) => {\n      // When the generation is stopped before streaming any VISIBLE assistant message, this means that $progress, $attachment and $debug properties will be lost.\n      // However, the \"ContextMessage\" frames will be persisted in the chatHistory and the assistant may reference them in the next generation.\n      // This leads to the problem of referencing undisplayed attachments in the next generation.\n      // To solve this problem, we need to persist $progress, $attachment and $debug properties by adding a new assistant message with empty content and these properties.\n      // In the other hand, this leads to the problem of having many empty assistant messages in the chat history, if a stop generation happens multiple times in a row with no content generated yet.\n      // To solve this problem mentioned in the ticket ES-27024, we need to allow such operation ONLY if the last assistant message's content in the chat history is not empty.\n      const chatHistory = context.getChatHistory();\n      const isLastChatHistoryMessageAssistantContentEmpty = chatHistory?.length\n                                                    &&  chatHistory.at(-1)?.role === \"assistant\"\n                                                    && (chatHistory.at(-1)?.content === \"\"\n                                                        ||\n                                                        ((chatHistory.at(-1)?.content as MessageContent[])?.find((msg) => msg.type === \"text\") as TextMessageContent)?.text === \"\"\n                                                      );\n      if (this._response && this._response.length === 1 && this._response[0].content === \"\" && !isLastChatHistoryMessageAssistantContentEmpty) {\n        const newChatHistory = chatHistory ? [...chatHistory] : [];\n        newChatHistory.push({role: \"assistant\", content: \"\", additionalProperties: {display: true, messageId: guid(), $progress: this._progress, $attachment: this._attachments, $debug: this._debugMessages}});\n        context.setChatHistory(newChatHistory);\n      }\n      // Emit the result of the CancelTasks method\n      stopGenerationSubject$.next(!!res);\n      // Complete the subject\n      stopGenerationSubject$.complete();\n      // Complete stopping generation\n      context.setStoppingGenerationStatus(false);\n    });\n\n    // Invoke the CancelTasks method and handle errors\n    connection.invoke('CancelTasks')\n      .catch(error => {\n        console.error('Error invoking CancelTasks:', error);\n        stopGenerationSubject$.error(new Error(error as string));\n        context.setStoppingGenerationStatus(false);\n        return Promise.resolve();\n      });\n\n    return stopGenerationSubject$.asObservable();\n  }\n}\n"]}

package/esm2022/chat/services/signalR-connection.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpTransportType, LogLevel } from '@microsoft/signalr';
+import { getToken } from '@sinequa/atomic';
+import { AssistantUtils } from '../utils/utils.service';
+import { SignalRWebService } from './signalR.web.service';
+import * as i0 from "@angular/core";
+export class SignalRConnectionService {
+    constructor() {
+        this.signalRWebService = inject(SignalRWebService);
+        this.assistantUtils = inject(AssistantUtils);
+    }
+    init(config) {
+        this.operationConfig = config;
+    }
+    ensureInitialized() {
+        if (!this.operationConfig) {
+            throw new Error('SignalRConnectionService not initialized. Call init() first.');
+        }
+    }
+    _getLogLevel() {
+        this.ensureInitialized();
+        const assistantConfig = this.operationConfig.getAssistantConfigValue();
+        switch (assistantConfig?.connectionSettings.signalRLogLevel) {
+            case "Critical": return LogLevel.Critical;
+            case "Debug": return LogLevel.Debug;
+            case "Error": return LogLevel.Error;
+            case "Information": return LogLevel.Information;
+            case "None": return LogLevel.None;
+            case "Trace": return LogLevel.Trace;
+            case "Warning": return LogLevel.Warning;
+            default: return LogLevel.None;
+        }
+    }
+    _getTransports() {
+        this.ensureInitialized();
+        const assistantConfig = this.operationConfig.getAssistantConfigValue();
+        switch (assistantConfig?.connectionSettings.signalRTransport) {
+            case "WebSockets": return HttpTransportType.WebSockets;
+            case "ServerSentEvents": return HttpTransportType.ServerSentEvents;
+            case "LongPolling": return HttpTransportType.LongPolling;
+            default: return HttpTransportType.None;
+        }
+    }
+    getDefaultOptions() {
+        this.ensureInitialized();
+        let headers = {
+            "sinequa-force-camel-case": "true",
+            "x-language": this.assistantUtils.getCurrentLocaleName(),
+            "ui-language": this.assistantUtils.getCurrentLocaleName(),
+        };
+        const token = getToken();
+        if (token) {
+            headers = { ...headers, "sinequa-csrf-token": token };
+        }
+        return {
+            transport: this._getTransports(),
+            withCredentials: true,
+            headers,
+            skipNegotiation: false,
+            accessTokenFactory: () => token || ""
+        };
+    }
+    buildConnection(options) {
+        this.ensureInitialized();
+        return new Promise((resolve, reject) => {
+            const wsRequestUrl = this.operationConfig.getWsRequestUrl();
+            if (!wsRequestUrl) {
+                reject(new Error("No endpoint provided to connect the websocket to"));
+                return;
+            }
+            const assistantConfig = this.operationConfig.getAssistantConfigValue();
+            const logLevel = this._getLogLevel();
+            const defaultOpts = this.getDefaultOptions();
+            if (assistantConfig?.connectionSettings.signalRSkipNegotiation === true) {
+                options = { ...options, skipNegotiation: true };
+            }
+            const connection = this.signalRWebService.buildConnection(wsRequestUrl, { ...defaultOpts, ...options }, logLevel, true);
+            const signalRServerTimeoutInMilliseconds = assistantConfig?.connectionSettings.signalRServerTimeoutInMilliseconds;
+            if (signalRServerTimeoutInMilliseconds && connection) {
+                connection.serverTimeoutInMilliseconds = signalRServerTimeoutInMilliseconds;
+            }
+            this.operationConfig.setHubConnection(connection);
+            resolve();
+        });
+    }
+    startConnection() {
+        this.ensureInitialized();
+        const connection = this.operationConfig.getHubConnection();
+        return this.signalRWebService.startConnection(connection);
+    }
+    stopConnection() {
+        this.ensureInitialized();
+        const connection = this.operationConfig.getHubConnection();
+        return this.signalRWebService.stopConnection(connection);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SignalRConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SignalRConnectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SignalRConnectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalR-connection.service.js","sourceRoot":"","sources":["../../../../../projects/assistant/chat/services/signalR-connection.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HubConnection, HttpTransportType, LogLevel, MessageHeaders } from '@microsoft/signalr';\nimport { getToken } from '@sinequa/atomic';\nimport { AssistantUtils } from '../utils/utils.service';\nimport { SignalRWebService, ConnectionOptions } from './signalR.web.service';\nimport { ChatConfig } from '../types';\n\nexport interface SignalRConnectionOperationConfig {\n  getWsRequestUrl: () => string;\n  getAssistantConfigValue: () => ChatConfig | undefined;\n  getHubConnection: () => HubConnection | undefined;\n  setHubConnection: (connection: HubConnection | undefined) => void;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SignalRConnectionService {\n  private operationConfig: SignalRConnectionOperationConfig | undefined;\n  private signalRWebService = inject(SignalRWebService);\n  private assistantUtils = inject(AssistantUtils);\n\n  public init(config: SignalRConnectionOperationConfig): void {\n    this.operationConfig = config;\n  }\n\n  private ensureInitialized(): void {\n    if (!this.operationConfig) {\n      throw new Error('SignalRConnectionService not initialized. Call init() first.');\n    }\n  }\n\n  private _getLogLevel(): LogLevel {\n    this.ensureInitialized();\n    const assistantConfig = this.operationConfig!.getAssistantConfigValue();\n    switch (assistantConfig?.connectionSettings.signalRLogLevel) {\n      case \"Critical\": return LogLevel.Critical;\n      case \"Debug\": return LogLevel.Debug;\n      case \"Error\": return LogLevel.Error;\n      case \"Information\": return LogLevel.Information;\n      case \"None\": return LogLevel.None;\n      case \"Trace\": return LogLevel.Trace;\n      case \"Warning\": return LogLevel.Warning;\n      default: return LogLevel.None;\n    }\n  }\n\n  private _getTransports(): HttpTransportType {\n    this.ensureInitialized();\n    const assistantConfig = this.operationConfig!.getAssistantConfigValue();\n    switch (assistantConfig?.connectionSettings.signalRTransport) {\n      case \"WebSockets\": return HttpTransportType.WebSockets;\n      case \"ServerSentEvents\": return HttpTransportType.ServerSentEvents;\n      case \"LongPolling\": return HttpTransportType.LongPolling;\n      default: return HttpTransportType.None;\n    }\n  }\n\n  private getDefaultOptions(): ConnectionOptions {\n    this.ensureInitialized();\n    let headers: MessageHeaders = {\n      \"sinequa-force-camel-case\": \"true\",\n      \"x-language\": this.assistantUtils.getCurrentLocaleName(),\n      \"ui-language\": this.assistantUtils.getCurrentLocaleName(),\n    };\n    const token = getToken();\n    if (token) {\n      headers = { ...headers, \"sinequa-csrf-token\": token };\n    }\n\n    return {\n      transport: this._getTransports(),\n      withCredentials: true,\n      headers,\n      skipNegotiation: false,\n      accessTokenFactory: () => token || \"\"\n    };\n  }\n\n  public buildConnection(options?: ConnectionOptions): Promise<void> {\n    this.ensureInitialized();\n    return new Promise<void>((resolve, reject) => {\n      const wsRequestUrl = this.operationConfig!.getWsRequestUrl();\n      if (!wsRequestUrl) {\n        reject(new Error(\"No endpoint provided to connect the websocket to\"));\n        return;\n      }\n      const assistantConfig = this.operationConfig!.getAssistantConfigValue();\n      const logLevel = this._getLogLevel();\n      const defaultOpts = this.getDefaultOptions();\n      if (assistantConfig?.connectionSettings.signalRSkipNegotiation === true) {\n        options = {...options, skipNegotiation: true};\n      }\n      const connection = this.signalRWebService.buildConnection(wsRequestUrl, { ...defaultOpts, ...options }, logLevel, true);\n\n      const signalRServerTimeoutInMilliseconds = assistantConfig?.connectionSettings.signalRServerTimeoutInMilliseconds;\n      if (signalRServerTimeoutInMilliseconds && connection) {\n        connection.serverTimeoutInMilliseconds = signalRServerTimeoutInMilliseconds;\n      }\n      this.operationConfig!.setHubConnection(connection);\n      resolve();\n    });\n  }\n\n  public startConnection(): Promise<void> {\n    this.ensureInitialized();\n    const connection = this.operationConfig!.getHubConnection();\n    return this.signalRWebService.startConnection(connection);\n  }\n\n  public stopConnection(): Promise<void> {\n    this.ensureInitialized();\n    const connection = this.operationConfig!.getHubConnection();\n    return this.signalRWebService.stopConnection(connection);\n  }\n}\n"]}