@sinequa/assistant 3.1.1

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

@@ -0,0 +1,164 @@
+import { Injectable, inject } from '@angular/core';
+import { ChatService } from './chat.service';
+import { catchError, filter, finalize, forkJoin, map, shareReplay, switchMap, tap, throwError } from 'rxjs';
+import { JsonMethodPluginService } from '@sinequa/core/web-services';
+import * as i0 from "@angular/core";
+export class RestChatService extends ChatService {
+    constructor() {
+        super();
+        this.jsonMethodWebService = inject(JsonMethodPluginService);
+    }
+    /**
+     * Initialize the chat process after the login is complete.
+     * It listens for the 'login-complete' event, initializes necessary URL, and performs parallel requests for models, functions and quota data.
+     * @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()), 
+        // Execute parallel requests for models and functions
+        switchMap(() => forkJoin([
+            this.listModels(),
+            this.listFunctions()
+        ])), 
+        // Map the results of parallel requests to a boolean indicating success
+        map(([models, functions]) => !!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, ensuring the initialization logic is only executed once even if there are multiple subscribers
+        shareReplay(1));
+    }
+    /**
+     * Define the GLLM plugin to use for the http requests
+     * It can be overridden by the app config
+     */
+    getRequestsUrl() {
+        if (this.chatConfig$.value.globalSettings.restEndpoint) {
+            this.REQUEST_URL = this.chatConfig$.value.globalSettings.restEndpoint;
+        }
+        else {
+            throw new Error(`The property 'restEndpoint' must be provided when attempting to use 'REST' in assistant instance`);
+        }
+    }
+    listModels() {
+        const data = {
+            action: "listmodels",
+            debug: this.chatConfig$.value.debug
+        };
+        return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(map(res => res.models), tap(models => this.models = models?.filter(model => !!model.enable)), catchError((error) => {
+            console.error('Error invoking listmodels:', error);
+            return throwError(() => error);
+        }));
+    }
+    listFunctions() {
+        const data = {
+            action: "listfunctions",
+            debug: this.chatConfig$.value.debug
+        };
+        return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(map(res => res.functions), tap(functions => this.functions = functions), catchError((error) => {
+            console.error('Error invoking listfunctions:', error);
+            return throwError(() => error);
+        }));
+    }
+    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 = {
+            action: "chat",
+            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;
+        }
+        // Request the Chat endpoint
+        return this.jsonMethodWebService.post(this.REQUEST_URL, data).pipe(tap((res) => {
+            if (res.quota.maxQuotaReached) {
+                const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${this.formatDateTime(res.quota.nextResetUTC)}.`;
+                this.notificationsService.error(msg);
+                throw new Error(msg);
+            }
+        }), map((res) => {
+            // Define $progress from the actions property of the response
+            let $progress;
+            if (res.actions?.length > 0) {
+                const actions = Object.values(res.actions.reduce((acc, item) => {
+                    acc[item.guid] = { ...(acc[item.guid] || {}), ...item };
+                    return acc;
+                }, {}));
+                $progress = actions.map((a) => ({
+                    title: a.displayName ?? "",
+                    content: a.displayValue ?? "",
+                    done: a.executionTime !== undefined,
+                    time: a.executionTime,
+                }));
+            }
+            // Define the response message
+            const response = { ...res.history.at(-1), additionalProperties: { display: true } };
+            if ($progress) {
+                response.additionalProperties.$progress = $progress;
+            }
+            if (res.context) {
+                response.additionalProperties.$attachment = res.context.map((ctx) => ctx.additionalProperties);
+            }
+            // Update the chat history with the history property of the res
+            this.chatHistory = res.history;
+            // Return the result
+            return { history: [...messages, response], executionTime: res.executionTime };
+        }), tap(() => this.notifyAudit(this.chatHistory, this.chatConfig$.value.serviceSettings.service_id)), finalize(() => this.streaming$.next(false)));
+    }
+    listSavedChat() {
+        const data = {
+            action: "SavedChatList",
+            instanceId: this.chatInstanceId,
+            debug: this.chatConfig$.value.debug
+        };
+        this.jsonMethodWebService.get(this.REQUEST_URL, data).subscribe(res => this.savedChats$.next(res.savedChats), error => {
+            console.error('Error occurred while calling the SavedChatList API:', error);
+            this.notificationsService.error('Error occurred while calling the SavedChatList API');
+        });
+    }
+    getSavedChat(id) {
+        const data = {
+            action: "SavedChatGet",
+            instanceId: this.chatInstanceId,
+            savedChatId: id,
+            debug: this.chatConfig$.value.debug
+        };
+        return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(map(res => res.savedChat), catchError((error) => {
+            console.error('Error occurred while calling the SavedChatGet API:', error);
+            this.notificationsService.error('Error occurred while calling the SavedChatGet API');
+            return throwError(() => error);
+        }));
+    }
+    deleteSavedChat(ids) {
+        const data = {
+            action: "SavedChatDelete",
+            instanceId: this.chatInstanceId,
+            savedChatIds: ids,
+            debug: this.chatConfig$.value.debug
+        };
+        return this.jsonMethodWebService.post(this.REQUEST_URL, data).pipe(map(res => res.deletedCount), catchError((error) => {
+            console.error('Error occurred while calling the SavedChatDelete API:', error);
+            this.notificationsService.error('Error occurred while calling the SavedChatDelete API ');
+            return throwError(() => error);
+        }));
+    }
+}
+RestChatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: RestChatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RestChatService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: RestChatService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: RestChatService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-chat.service.js","sourceRoot":"","sources":["../../../../projects/assistant/chat/rest-chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { ChatService } from './chat.service';\nimport { Observable, catchError, filter, finalize, forkJoin, map, shareReplay, switchMap, tap, throwError } from 'rxjs';\nimport { ActionMessage, ChatMessage, ChatPayload, ChatProgress, ChatResponse, GllmFunction, GllmModelDescription, HttpChatResponse, SavedChatHistory } from './types';\nimport { JsonMethodPluginService } from '@sinequa/core/web-services';\n\n@Injectable()\nexport class RestChatService extends ChatService {\n\n  public jsonMethodWebService = inject(JsonMethodPluginService);\n\n  constructor() {\n    super();\n  }\n\n  /**\n   * Initialize the chat process after the login is complete.\n   * It listens for the 'login-complete' event, initializes necessary URL, and performs parallel requests for models, functions and quota data.\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      // Execute parallel requests for models and functions\n      switchMap(() =>\n        forkJoin([\n          this.listModels(),\n          this.listFunctions()\n        ])\n      ),\n      // Map the results of parallel requests to a boolean indicating success\n      map(([models, functions]) => !!models && !!functions),\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, ensuring the initialization logic is only executed once even if there are multiple subscribers\n      shareReplay(1)\n    );\n  }\n\n  /**\n   * Define the GLLM plugin to use for the http requests\n   * It can be overridden by the app config\n   */\n  getRequestsUrl() {\n    if (this.chatConfig$.value!.globalSettings.restEndpoint) {\n      this.REQUEST_URL = this.chatConfig$.value!.globalSettings.restEndpoint;\n    } else {\n      throw new Error(`The property 'restEndpoint' must be provided when attempting to use 'REST' in assistant instance`);\n    }\n  }\n\n  listModels(): Observable<GllmModelDescription[] | undefined> {\n    const data = {\n      action: \"listmodels\",\n      debug: this.chatConfig$.value!.debug\n    };\n    return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(\n      map(res => res.models),\n      tap(models => this.models = models?.filter(model => !!model.enable)),\n      catchError((error) => {\n        console.error('Error invoking listmodels:', error);\n        return throwError(() => error);\n      })\n    );\n  }\n\n  listFunctions(): Observable<GllmFunction[] | undefined> {\n    const data = {\n      action: \"listfunctions\",\n      debug: this.chatConfig$.value!.debug\n    };\n    return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(\n      map(res => res.functions),\n      tap(functions => this.functions = functions),\n      catchError((error) => {\n        console.error('Error invoking listfunctions:', error);\n        return throwError(() => error);\n      })\n    );\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 & {action: \"chat\"} = {\n      action: \"chat\",\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    // Request the Chat endpoint\n    return this.jsonMethodWebService.post(this.REQUEST_URL, data).pipe(\n      tap((res: HttpChatResponse) => {\n        if(res.quota.maxQuotaReached) {\n          const msg = `Sorry, you have exceeded the allowed quota. Please retry starting from ${this.formatDateTime(res.quota.nextResetUTC)}.`;\n          this.notificationsService.error(msg);\n          throw new Error(msg);\n        }\n      }),\n      map((res: HttpChatResponse) => {\n        // Define $progress from the actions property of the response\n        let $progress: ChatProgress[] | undefined;\n        if( res.actions?.length > 0) {\n          const actions: ActionMessage[] = Object.values(res.actions.reduce((acc, item) => {\n            acc[item.guid] = { ...(acc[item.guid] || {}), ...item };\n            return acc;\n          }, {}));\n          $progress = actions.map((a) => ({\n            title: a.displayName ?? \"\",\n            content: a.displayValue ?? \"\",\n            done: a.executionTime !== undefined,\n            time: a.executionTime,\n          }))\n        }\n        // Define the response message\n        const response = {...(res.history as Array<ChatMessage>).at(-1), additionalProperties: {display: true}} as ChatMessage;\n        if($progress) {\n          response.additionalProperties.$progress = $progress;\n        }\n        if(res.context) {\n          response.additionalProperties.$attachment = res.context.map((ctx) => ctx.additionalProperties);\n        }\n        // Update the chat history with the history property of the res\n        this.chatHistory = res.history;\n        // Return the result\n        return { history: [...messages, response], executionTime: res.executionTime };\n      }),\n      tap(() => this.notifyAudit(this.chatHistory!, this.chatConfig$.value!.serviceSettings.service_id)),\n      finalize(() => this.streaming$.next(false))\n    );\n  }\n\n  listSavedChat(): void {\n    const data = {\n      action: \"SavedChatList\",\n      instanceId: this.chatInstanceId,\n      debug: this.chatConfig$.value!.debug\n    };\n    this.jsonMethodWebService.get(this.REQUEST_URL, data).subscribe(\n      res => this.savedChats$.next(res.savedChats),\n      error => {\n        console.error('Error occurred while calling the SavedChatList API:', error);\n        this.notificationsService.error('Error occurred while calling the SavedChatList API');\n      }\n      );\n  }\n\n  getSavedChat(id: string): Observable<SavedChatHistory | undefined> {\n    const data = {\n      action: \"SavedChatGet\",\n      instanceId: this.chatInstanceId,\n      savedChatId: id,\n      debug: this.chatConfig$.value!.debug\n    };\n    return this.jsonMethodWebService.get(this.REQUEST_URL, data).pipe(\n      map(res => res.savedChat),\n      catchError((error) => {\n        console.error('Error occurred while calling the SavedChatGet API:', error);\n        this.notificationsService.error('Error occurred while calling the SavedChatGet API');\n        return throwError(() => error);\n      })\n    );\n  }\n\n  deleteSavedChat(ids: string[]): Observable<number> {\n    const data = {\n      action: \"SavedChatDelete\",\n      instanceId: this.chatInstanceId,\n      savedChatIds: ids,\n      debug: this.chatConfig$.value!.debug\n    };\n    return this.jsonMethodWebService.post(this.REQUEST_URL, data).pipe(\n      map(res => res.deletedCount),\n      catchError((error) => {\n        console.error('Error occurred while calling the SavedChatDelete API:', error);\n        this.notificationsService.error('Error occurred while calling the SavedChatDelete API ');\n        return throwError(() => error);\n      })\n    );\n  }\n\n}\n"]}

package/esm2020/chat/saved-chats/saved-chats.component.mjs

@@ -0,0 +1,132 @@
+import { Component, EventEmitter, Input, Output, inject } from "@angular/core";
+import { AuditWebService } from "@sinequa/core/web-services";
+import { InstanceManagerService } from "../instance-manager.service";
+import { Subscription, catchError, filter, switchMap, tap, throwError, BehaviorSubject } from "rxjs";
+import { CommonModule } from "@angular/common";
+import { LoginService } from "@sinequa/core/login";
+import { ModalButton, ModalModule, ModalService } from "@sinequa/core/modal";
+import { NotificationsService } from "@sinequa/core/notification";
+import { UtilsModule } from "@sinequa/components/utils";
+import { format, parseISO, isToday, isYesterday, isThisWeek, isThisMonth, isThisQuarter, isThisYear, endOfYesterday, differenceInDays, differenceInMonths, differenceInYears } from 'date-fns';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@sinequa/components/utils";
+export class SavedChatsComponent {
+    constructor() {
+        this.load = new EventEmitter();
+        this.delete = new EventEmitter();
+        this.subscription = new Subscription();
+        this.groupedSavedChats$ = new BehaviorSubject([]);
+        this.loginService = inject(LoginService);
+        this.instanceManagerService = inject(InstanceManagerService);
+        this.auditService = inject(AuditWebService);
+        this.modalService = inject(ModalService);
+        this.notificationsService = inject(NotificationsService);
+    }
+    ngOnInit() {
+        this.subscription.add(this.loginService.events.pipe(filter(e => e.type === 'login-complete'), tap(_ => this.instantiateChatService()), switchMap(_ => this.chatService.initProcess$), filter(success => !!success), tap(_ => {
+            this.onListSavedChat();
+            this.chatService.listSavedChat();
+        })).subscribe());
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    instantiateChatService() {
+        this.chatService = this.instanceManagerService.getInstance(this.instanceId);
+    }
+    onListSavedChat() {
+        this.subscription.add(this.chatService.savedChats$.subscribe((savedChats) => this.groupedSavedChats$.next(this._groupSavedChatsByDate(savedChats))));
+    }
+    onLoad(savedChat) {
+        this.chatService.loadSavedChat$.next(savedChat);
+        this.load.emit(savedChat);
+    }
+    onDelete(savedChat) {
+        this.modalService
+            .confirm({
+            title: "Delete saved discussion",
+            message: `You are about to delete the discussion "${savedChat.title}". Do you want to continue?`,
+            buttons: [
+                new ModalButton({ result: -2 /* ModalResult.Cancel */ }),
+                new ModalButton({ result: -1 /* ModalResult.OK */, text: "Confirm", primary: true })
+            ],
+            confirmType: 2 /* ConfirmType.Warning */
+        }).then(res => {
+            if (res === -1 /* ModalResult.OK */) {
+                this.subscription.add(this.chatService.deleteSavedChat([savedChat.id])
+                    .pipe(tap(() => {
+                    this.notificationsService.success(`The saved discussion "${savedChat.title}" has been successfully deleted.`);
+                    this.delete.emit(savedChat);
+                    this.chatService.listSavedChat();
+                }), catchError((error) => {
+                    console.error('Error occurred while deleting the saved chat:', error);
+                    this.notificationsService.error(`Error occurred while deleting the saved discussion "${savedChat.title}"`);
+                    return throwError(() => error);
+                })).subscribe());
+            }
+        });
+    }
+    _groupSavedChatsByDate(savedChats) {
+        const groupedSavedChats = new Map();
+        savedChats
+            .sort((a, b) => parseISO(b.modifiedUTC).getTime() - parseISO(a.modifiedUTC).getTime())
+            .forEach(savedChat => {
+            const groupKey = this._getTimeKey(parseISO(savedChat.modifiedUTC));
+            if (!groupedSavedChats.has(groupKey)) {
+                groupedSavedChats.set(groupKey, []);
+            }
+            groupedSavedChats.get(groupKey).push(savedChat);
+        });
+        return Array.from(groupedSavedChats, ([key, value]) => ({ key, value }));
+        ;
+    }
+    _getTimeKey(date) {
+        if (isToday(date)) {
+            return 'Today';
+        }
+        else if (isYesterday(date)) {
+            return 'Yesterday';
+        }
+        else if (isThisWeek(date)) {
+            return 'This week';
+        }
+        else if (differenceInDays(endOfYesterday(), date) <= 7) {
+            return 'Last week';
+        }
+        else if (isThisMonth(date)) {
+            return 'This month';
+        }
+        else if (differenceInMonths(endOfYesterday(), date) <= 1) {
+            return 'Last month';
+        }
+        else if (isThisQuarter(date)) {
+            return 'This quarter';
+        }
+        else if (differenceInMonths(endOfYesterday(), date) <= 3) {
+            return 'Last quarter';
+        }
+        else if (isThisYear(date)) {
+            return 'This year';
+        }
+        else if (differenceInYears(endOfYesterday(), date) === 1) {
+            return 'Last year';
+        }
+        else {
+            return format(date, 'yyyy');
+        }
+    }
+}
+SavedChatsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: SavedChatsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SavedChatsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: SavedChatsComponent, isStandalone: true, selector: "sq-saved-chats-v3", inputs: { instanceId: "instanceId" }, outputs: { load: "load", delete: "delete" }, ngImport: i0, template: "<div *ngFor=\"let group of (groupedSavedChats$ | async)\" class=\"saved-chats\">\n    <div class=\"saved-chat-date\">{{group.key}}</div>\n    <div *ngFor=\"let savedChat of group.value\" class=\"saved-chat p-2\">\n      <span class=\"title me-1\" (click)=\"onLoad(savedChat)\">{{savedChat.title}}</span>\n      <i class=\"saved-chat-actions fas fa-trash ms-1\" [sqTooltip]=\"'Delete'\" (click)=\"onDelete(savedChat)\"></i>\n    </div>\n</div>\n", styles: [".saved-chats .saved-chat-date{font-weight:500;color:#a9a9a9;margin-top:.5rem}.saved-chats .saved-chat{display:flex;align-items:center;cursor:pointer;margin-left:.25rem}.saved-chats .saved-chat span{flex-grow:1;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.saved-chats .saved-chat .saved-chat-actions{display:none}.saved-chats .saved-chat:hover{color:#ff732e;background-color:#fff8f1}.saved-chats .saved-chat:hover .saved-chat-actions{display:block}.saved-chats .title{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ModalModule }, { kind: "ngmodule", type: UtilsModule }, { kind: "directive", type: i2.TooltipDirective, selector: "[sqTooltip]", inputs: ["sqTooltip", "sqTooltipData", "sqTooltipTemplate", "placement", "fallbackPlacements", "delay", "hoverableTooltip", "tooltipClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: SavedChatsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sq-saved-chats-v3', standalone: true, imports: [CommonModule, ModalModule, UtilsModule], template: "<div *ngFor=\"let group of (groupedSavedChats$ | async)\" class=\"saved-chats\">\n    <div class=\"saved-chat-date\">{{group.key}}</div>\n    <div *ngFor=\"let savedChat of group.value\" class=\"saved-chat p-2\">\n      <span class=\"title me-1\" (click)=\"onLoad(savedChat)\">{{savedChat.title}}</span>\n      <i class=\"saved-chat-actions fas fa-trash ms-1\" [sqTooltip]=\"'Delete'\" (click)=\"onDelete(savedChat)\"></i>\n    </div>\n</div>\n", styles: [".saved-chats .saved-chat-date{font-weight:500;color:#a9a9a9;margin-top:.5rem}.saved-chats .saved-chat{display:flex;align-items:center;cursor:pointer;margin-left:.25rem}.saved-chats .saved-chat span{flex-grow:1;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.saved-chats .saved-chat .saved-chat-actions{display:none}.saved-chats .saved-chat:hover{color:#ff732e;background-color:#fff8f1}.saved-chats .saved-chat:hover .saved-chat-actions{display:block}.saved-chats .title{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], propDecorators: { instanceId: [{
+                type: Input
+            }], load: [{
+                type: Output
+            }], delete: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"saved-chats.component.js","sourceRoot":"","sources":["../../../../../projects/assistant/chat/saved-chats/saved-chats.component.ts","../../../../../projects/assistant/chat/saved-chats/saved-chats.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnDestroy, OnInit, Output, inject } from \"@angular/core\";\nimport { AuditWebService } from \"@sinequa/core/web-services\";\nimport { ChatService } from \"../chat.service\";\nimport { SavedChat } from \"../types\";\nimport { InstanceManagerService } from \"../instance-manager.service\";\nimport { Subscription, catchError, filter, switchMap, tap, throwError, BehaviorSubject } from \"rxjs\";\nimport { CommonModule } from \"@angular/common\";\nimport { LoginService } from \"@sinequa/core/login\";\nimport { ConfirmType, ModalButton, ModalModule, ModalResult, ModalService } from \"@sinequa/core/modal\";\nimport { NotificationsService } from \"@sinequa/core/notification\";\nimport { UtilsModule } from \"@sinequa/components/utils\";\nimport { format, parseISO, isToday, isYesterday, isThisWeek, isThisMonth, isThisQuarter, isThisYear, endOfYesterday, differenceInDays, differenceInMonths, differenceInYears } from 'date-fns';\n\n@Component({\n  selector: 'sq-saved-chats-v3',\n  templateUrl: 'saved-chats.component.html',\n  styleUrls: ['saved-chats.component.scss'],\n  standalone: true,\n  imports: [CommonModule, ModalModule, UtilsModule]\n})\nexport class SavedChatsComponent implements OnInit, OnDestroy {\n  /** Define the key based on it, the appropriate chatService instance will be returned from instanceManagerService */\n  @Input() instanceId: string;\n\n  @Output() load = new EventEmitter<SavedChat>();\n  @Output() delete = new EventEmitter<SavedChat>();\n\n  chatService: ChatService;\n  subscription = new Subscription();\n  groupedSavedChats$ = new BehaviorSubject<{ key: string; value: SavedChat[]}[]>([]);\n\n  public loginService = inject(LoginService);\n  public instanceManagerService = inject(InstanceManagerService);\n  public auditService = inject(AuditWebService);\n  public modalService = inject(ModalService);\n  public notificationsService = inject(NotificationsService);\n\n  ngOnInit(): void {\n    this.subscription.add(\n      this.loginService.events.pipe(\n        filter(e => e.type === 'login-complete'),\n        tap(_ => this.instantiateChatService()),\n        switchMap(_ => this.chatService.initProcess$),\n        filter(success => !!success),\n        tap(_ => {\n          this.onListSavedChat();\n          this.chatService.listSavedChat();\n        })\n      ).subscribe()\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscription.unsubscribe();\n  }\n\n  instantiateChatService(): void {\n    this.chatService = this.instanceManagerService.getInstance(this.instanceId);\n  }\n\n  onListSavedChat() {\n    this.subscription.add(\n      this.chatService.savedChats$.subscribe(\n        (savedChats: SavedChat[]) => this.groupedSavedChats$.next(this._groupSavedChatsByDate(savedChats))\n      )\n    );\n  }\n\n  onLoad(savedChat: SavedChat) {\n    this.chatService.loadSavedChat$.next(savedChat);\n    this.load.emit(savedChat);\n  }\n\n  onDelete(savedChat: SavedChat) {\n    this.modalService\n      .confirm({\n          title: \"Delete saved discussion\",\n          message: `You are about to delete the discussion \"${savedChat.title}\". Do you want to continue?`,\n          buttons: [\n              new ModalButton({result: ModalResult.Cancel}),\n              new ModalButton({result: ModalResult.OK, text: \"Confirm\", primary: true})\n          ],\n          confirmType: ConfirmType.Warning\n      }).then(res => {\n          if(res === ModalResult.OK) {\n            this.subscription.add(\n              this.chatService.deleteSavedChat([savedChat.id])\n                .pipe(\n                  tap(() => {\n                    this.notificationsService.success(`The saved discussion \"${savedChat.title}\" has been successfully deleted.`);\n                    this.delete.emit(savedChat);\n                    this.chatService.listSavedChat();\n                  }),\n                  catchError((error) => {\n                    console.error('Error occurred while deleting the saved chat:', error);\n                    this.notificationsService.error(`Error occurred while deleting the saved discussion \"${savedChat.title}\"`);\n                    return throwError(() => error);\n                  })\n                ).subscribe()\n              );\n          }\n      });\n  }\n\n  private _groupSavedChatsByDate(savedChats: SavedChat[]): { key: string; value: SavedChat[] }[] {\n    const groupedSavedChats = new Map<string, SavedChat[]>();\n\n    savedChats\n      .sort((a, b) => parseISO(b.modifiedUTC).getTime() - parseISO(a.modifiedUTC).getTime())\n      .forEach(savedChat => {\n          const groupKey = this._getTimeKey(parseISO(savedChat.modifiedUTC));\n\n          if (!groupedSavedChats.has(groupKey)) {\n            groupedSavedChats.set(groupKey, []);\n          }\n\n          groupedSavedChats.get(groupKey)!.push(savedChat);\n      });\n\n    return Array.from(groupedSavedChats, ([key, value]) => ({ key, value }));;\n  }\n\n  private _getTimeKey(date: Date): string {\n    if (isToday(date)) {\n        return 'Today';\n    } else if (isYesterday(date)) {\n        return 'Yesterday';\n    } else if (isThisWeek(date)) {\n        return 'This week';\n    } else if (differenceInDays(endOfYesterday(), date) <= 7) {\n      return 'Last week';\n    } else if (isThisMonth(date)) {\n        return 'This month';\n    } else if (differenceInMonths(endOfYesterday(), date) <= 1) {\n      return 'Last month';\n    } else if (isThisQuarter(date)) {\n        return 'This quarter';\n    } else if (differenceInMonths(endOfYesterday(), date) <= 3) {\n        return 'Last quarter';\n    } else if (isThisYear(date)) {\n        return 'This year';\n    } else if (differenceInYears(endOfYesterday(), date) === 1) {\n        return 'Last year';\n    } else {\n        return format(date, 'yyyy');\n    }\n  }\n\n}\n","<div *ngFor=\"let group of (groupedSavedChats$ | async)\" class=\"saved-chats\">\n    <div class=\"saved-chat-date\">{{group.key}}</div>\n    <div *ngFor=\"let savedChat of group.value\" class=\"saved-chat p-2\">\n      <span class=\"title me-1\" (click)=\"onLoad(savedChat)\">{{savedChat.title}}</span>\n      <i class=\"saved-chat-actions fas fa-trash ms-1\" [sqTooltip]=\"'Delete'\" (click)=\"onDelete(savedChat)\"></i>\n    </div>\n</div>\n"]}

package/esm2020/chat/sinequa-assistant-chat.mjs

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

package/esm2020/chat/types.mjs

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+// Define the Zod representation for the globalSettings object
+export const globalSettingsSchema = z.object({
+    restEndpoint: z.string().optional(),
+    websocketEndpoint: z.string().optional(),
+    signalRTransport: z.enum(["WebSockets", "ServerSentEvents", "LongPolling", "None"]),
+    signalRLogLevel: z.enum(["Critical", "Debug", "Error", "Information", "None", "Trace", "Warning"])
+}).refine(data => (!!data.restEndpoint || !!data.websocketEndpoint), {
+    message: "Based on the provided input() protocol ('REST' or 'WEBSOCKET') to the Chat Component, either 'restEndpoint' or 'websocketEndpoint' property should be provided in the 'globalSettings' of the assistant instance.",
+});
+// Define the Zod representation for the serviceSettings object
+const serviceSettingsSchema = z.object({
+    service_id: z.string(),
+    model_id: z.string(),
+    temperature: z.number(),
+    top_p: z.number(),
+    maxTokens: z.number(),
+    results_per_prompt: z.number(),
+    presence_penalty: z.number(),
+    frequency_penalty: z.number(),
+});
+// Define the Zod representation for the TextChunksOptions interface
+const textChunksOptionsSchema = z.object({
+    extendMode: z.enum(['None', 'Sentence', 'Chars']).optional(),
+    extendScope: z.number().optional(),
+});
+// Define the Zod representation for the contextOptions object
+const contextOptionsSchema = z.object({
+    docColumns: z.array(z.string()),
+    textChunkFillGaps: z.number(),
+    html: z.boolean(),
+    topPassagesOptions: z.object({
+        topPassages: z.number(),
+        topPassagesMinScore: z.number(),
+        textChunkOptions: textChunksOptionsSchema,
+    }),
+    matchingPassagesOptions: z.object({
+        matchingPassagesPerDoc: z.number(),
+        fromTopDocuments: z.number(),
+        matchingPassagesMinScore: z.number(),
+        textChunkOptions: textChunksOptionsSchema,
+    }),
+    relevantExtractsOptions: z.object({
+        topRelevantExtractsPerDoc: z.number(),
+        fromTopDocuments: z.number(),
+        textChunkOptions: textChunksOptionsSchema,
+    }),
+    htmlOptions: z.object({
+        images: z.boolean(),
+        links: z.boolean(),
+        tables: z.boolean(),
+        extendTables: z.boolean(),
+    }),
+});
+// Define the Zod representation for the contextSettings object
+const contextSettingsSchema = z.object({
+    app: z.string().optional(),
+    query: z.object({}).optional(),
+    contextOptions: contextOptionsSchema,
+});
+// Define the Zod representation for the uiSettings object
+const uiSettingsSchema = z.object({
+    display: z.boolean(),
+    servicesModels: z.boolean(),
+    functions: z.boolean(),
+    temperature: z.boolean(),
+    top_p: z.boolean(),
+    maxTokens: z.boolean(),
+    debug: z.boolean(),
+    displaySystemPrompt: z.boolean(),
+    systemPrompt: z.string(),
+    displayUserPrompt: z.boolean(),
+    userPrompt: z.string(),
+});
+// Define the Zod representation for the entire ChatConfig object
+export const chatConfigSchema = z.object({
+    globalSettings: globalSettingsSchema,
+    serviceSettings: serviceSettingsSchema,
+    contextSettings: contextSettingsSchema,
+    uiSettings: uiSettingsSchema,
+    functions: z.array(z.string()),
+    debug: z.boolean(),
+    saveChats: z.boolean()
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../projects/assistant/chat/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqIxB,8DAA8D;AAC9D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACxC,gBAAgB,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;IACnF,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;CACnG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE;IACnE,OAAO,EAAE,mNAAmN;CAC7N,CAAC,CAAC;AAIH,+DAA+D;AAC/D,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC9B,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC5B,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE;CAC9B,CAAC,CAAC;AAIH,oEAAoE;AACpE,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC5D,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACnC,CAAC,CAAC;AAIH,8DAA8D;AAC9D,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC/B,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC7B,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;IACjB,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC;QAC3B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC/B,gBAAgB,EAAE,uBAAuB;KAC1C,CAAC;IACF,uBAAuB,EAAE,CAAC,CAAC,MAAM,CAAC;QAChC,sBAAsB,EAAE,CAAC,CAAC,MAAM,EAAE;QAClC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC5B,wBAAwB,EAAE,CAAC,CAAC,MAAM,EAAE;QACpC,gBAAgB,EAAE,uBAAuB;KAC1C,CAAC;IACF,uBAAuB,EAAE,CAAC,CAAC,MAAM,CAAC;QAChC,yBAAyB,EAAE,CAAC,CAAC,MAAM,EAAE;QACrC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC5B,gBAAgB,EAAE,uBAAuB;KAC1C,CAAC;IACF,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;QACpB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;QACnB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;QAClB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;QACnB,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE;KAC1B,CAAC;CACH,CAAC,CAAC;AAIH,+DAA+D;AAC/D,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC1B,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC9B,cAAc,EAAE,oBAAoB;CACrC,CAAC,CAAC;AAIH,0DAA0D;AAC1D,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE;IAC3B,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE;IACxB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,mBAAmB,EAAE,CAAC,CAAC,OAAO,EAAE;IAChC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,iBAAiB,EAAE,CAAC,CAAC,OAAO,EAAE;IAC9B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;CACvB,CAAC,CAAC;AAIH,iEAAiE;AACjE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,cAAc,EAAE,oBAAoB;IACpC,eAAe,EAAE,qBAAqB;IACtC,eAAe,EAAE,qBAAqB;IACtC,UAAU,EAAE,gBAAgB;IAC5B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;CACvB,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { Record } from \"@sinequa/core/web-services\";\n\n/**\n * Individual message sent & returned by the ChatGPT API.\n * If this message is an attachment, we attach the minimal\n * information needed to reconstruct this attachment (RawAttachment)\n * as well as the reference id computed at the moment of sending\n * the attachment to the API.\n */\n// DONE\nexport interface RawMessage {\n  role: string;\n  content: string;\n  additionalProperties: {\n    [key: string]: any\n  };\n}\n\n/**\n * A chat message that has been processed to include the markdown-formatted\n * content for display, as well as detailed attachment data, and optionally\n * a list of the references extracted from that message\n */\n// DONE\nexport interface ChatMessage extends RawMessage {\n  additionalProperties: {\n    display?: boolean;\n    $progress?: ChatProgress[];\n    $attachment?: ChatContextAttachment[];\n    [key: string]: any;\n  };\n}\n// DONE\nexport interface ChatProgress {\n    title: string;\n    content?: string;\n    done?: boolean;\n    time?: number;\n}\n\n// DONE\nexport interface RawAttachment {\n  /** Type of the attachment */\n  type: string;\n  /** Record id from which this attachment is taken */\n  recordId: string;\n  /** Record from which this this attachment is taken */\n  record: Record;\n}\n\n// DONE\nexport interface DocumentPart {\n  partId: number;\n  offset: number;\n  length: number;\n  text: string;\n}\n\n// DONE\nexport interface ChatContextAttachment extends RawAttachment {\n  /** Type of the attachment */\n  type: \"Context\";\n  /** Rank of the attachment in the context message */\n  contextId: number;\n  /** Parts of the record that the assistant uses to answer */\n  parts: DocumentPart[];\n  /** The specific id of used the referenced part */\n  $partId?: number;\n}\n\n/**\n * Raw response of the API\n */\n// DONE\nexport interface RawResponse {\n  history: RawMessage[];\n  executionTime: string;\n}\n\n/**\n * Enriched response of the API\n */\n// DONE\nexport interface ChatResponse extends RawResponse{\n  history: ChatMessage[];\n}\n\n// DONE\nexport interface GllmModelDescription {\n  provider: string;\n  displayName: string;\n  serviceId: string;\n  modelId: string;\n  size: number;\n  enable: boolean;\n  supportStreaming: boolean;\n  supportFunctions: boolean;\n}\n\n// DONE\nexport interface GllmFunction {\n  functionName: string;\n  fullyQualifiedName: string;\n  description: string;\n  pluginName: string;\n  parameters: GllmFunctionParameter[];\n}\n\n// DONE\nexport interface GllmFunctionParameter {\n  description: string;\n  isRequired: boolean;\n  name: string;\n  type: string;\n}\n\n/**\n * Minimal representation of a saved chat\n */\nexport interface SavedChat {\n  id: string;\n  title: string;\n  modifiedUTC: string;\n}\n\n/**\n * Data structure saved to reconstruct a conversation\n */\nexport interface SavedChatHistory extends SavedChat{\n  History: ChatMessage[];\n}\n\n// Define the Zod representation for the globalSettings object\nexport const globalSettingsSchema = z.object({\n  restEndpoint: z.string().optional(),\n  websocketEndpoint: z.string().optional(),\n  signalRTransport: z.enum([\"WebSockets\", \"ServerSentEvents\", \"LongPolling\", \"None\"]),\n  signalRLogLevel: z.enum([\"Critical\", \"Debug\", \"Error\", \"Information\", \"None\", \"Trace\", \"Warning\"])\n}).refine(data => (!!data.restEndpoint || !!data.websocketEndpoint), {\n  message: \"Based on the provided input() protocol ('REST' or 'WEBSOCKET') to the Chat Component, either 'restEndpoint' or 'websocketEndpoint' property should be provided in the 'globalSettings' of the assistant instance.\",\n});\n// Define the GlobalSettings interface\nexport type GlobalSettings = z.infer<typeof globalSettingsSchema>;\n\n// Define the Zod representation for the serviceSettings object\nconst serviceSettingsSchema = z.object({\n  service_id: z.string(),\n  model_id: z.string(),\n  temperature: z.number(),\n  top_p: z.number(),\n  maxTokens: z.number(),\n  results_per_prompt: z.number(),\n  presence_penalty: z.number(),\n  frequency_penalty: z.number(),\n});\n// Define the ServiceSettings interface\nexport interface ServiceSettings extends z.infer<typeof serviceSettingsSchema> {}\n\n// Define the Zod representation for the TextChunksOptions interface\nconst textChunksOptionsSchema = z.object({\n  extendMode: z.enum(['None', 'Sentence', 'Chars']).optional(),\n  extendScope: z.number().optional(),\n});\n// Define the TextChunksOptions interface\nexport interface TextChunksOptions extends z.infer<typeof textChunksOptionsSchema> {}\n\n// Define the Zod representation for the contextOptions object\nconst contextOptionsSchema = z.object({\n  docColumns: z.array(z.string()),\n  textChunkFillGaps: z.number(),\n  html: z.boolean(),\n  topPassagesOptions: z.object({\n    topPassages: z.number(),\n    topPassagesMinScore: z.number(),\n    textChunkOptions: textChunksOptionsSchema,\n  }),\n  matchingPassagesOptions: z.object({\n    matchingPassagesPerDoc: z.number(),\n    fromTopDocuments: z.number(),\n    matchingPassagesMinScore: z.number(),\n    textChunkOptions: textChunksOptionsSchema,\n  }),\n  relevantExtractsOptions: z.object({\n    topRelevantExtractsPerDoc: z.number(),\n    fromTopDocuments: z.number(),\n    textChunkOptions: textChunksOptionsSchema,\n  }),\n  htmlOptions: z.object({\n    images: z.boolean(),\n    links: z.boolean(),\n    tables: z.boolean(),\n    extendTables: z.boolean(),\n  }),\n});\n// Define the ContextOptions interface\nexport interface ContextOptions extends z.infer<typeof contextOptionsSchema> {}\n\n// Define the Zod representation for the contextSettings object\nconst contextSettingsSchema = z.object({\n  app: z.string().optional(),\n  query: z.object({}).optional(),\n  contextOptions: contextOptionsSchema,\n});\n// Define the ContextSettings interface\nexport interface ContextSettings extends z.infer<typeof contextSettingsSchema> {}\n\n// Define the Zod representation for the uiSettings object\nconst uiSettingsSchema = z.object({\n  display: z.boolean(),\n  servicesModels: z.boolean(),\n  functions: z.boolean(),\n  temperature: z.boolean(),\n  top_p: z.boolean(),\n  maxTokens: z.boolean(),\n  debug: z.boolean(),\n  displaySystemPrompt: z.boolean(),\n  systemPrompt: z.string(),\n  displayUserPrompt: z.boolean(),\n  userPrompt: z.string(),\n});\n// Define the UiSettings interface\nexport interface UiSettings extends z.infer<typeof uiSettingsSchema> {}\n\n// Define the Zod representation for the entire ChatConfig object\nexport const chatConfigSchema = z.object({\n  globalSettings: globalSettingsSchema,\n  serviceSettings: serviceSettingsSchema,\n  contextSettings: contextSettingsSchema,\n  uiSettings: uiSettingsSchema,\n  functions: z.array(z.string()),\n  debug: z.boolean(),\n  saveChats: z.boolean()\n});\n// Define the UiSettings interface\nexport interface ChatConfig extends z.infer<typeof chatConfigSchema> {}\n\n// DONE\nexport interface ChatPayload {\n  functions: string[];\n  debug: boolean;\n  serviceSettings: ServiceSettings;\n  contextSettings: ContextSettings;\n  history: ChatMessage[];\n  instanceId?: string;\n  savedChatId?: string;\n}\n// DONE\nexport type ActionMessage = {\n  guid: string;\n  displayName?: string\n  displayValue?: string;\n  executionTime?: number;\n}\n// DONE\nexport interface TextChunksOptions {\n  extendMode?: 'None' | 'Sentence' | 'Chars';\n  extendScope?: number;\n}\n// DONE\nexport interface Quota {\n  lastRequest: string;\n  promptTokenCount: number;\n  completionTokenCount: number;\n  periodTokens: number;\n  resetHours: number;\n  tokenCount: number;\n  nextReset: string;\n  lastResetUTC: string;\n  nextResetUTC: string;\n  maxQuotaReached: boolean;\n}\n\n/**\n * List of events data that can be emitted by the websocket chat endpoint\n */\n// DONE\nexport type QuotaEvent = { quota: Quota };\nexport type MessageEvent = string;\nexport type ContextMessageEvent = { content: string; metadata: ChatContextAttachment };\nexport type ErrorEvent = string;\nexport type ActionStartEvent = { guid: string; displayName: string };\nexport type ActionResultEvent = { guid: string; displayValue: string };\nexport type ActionStopEvent = { guid: string; executionTime: number };\nexport type HistoryEvent = { history: RawMessage[]; executionTime: string };\n\n/**\n * Data emitted by the http chat endpoint\n */\n// DONE\nexport type HttpChatResponse = {\n  quota: Quota;\n  debug: any;\n  context: { content: string; additionalProperties: ChatContextAttachment }[];\n  actions: ActionMessage[];\n  history: RawMessage[];\n  executionTime: string;\n}\n// DONE\nexport type MessageHandler<T> = {\n  handler: (data: T) => void;\n  isGlobalHandler: boolean;\n};\n"]}