@servicetitan/titan-chatbot-api 4.0.1 → 4.1.0

package/src/stores/__tests__/chatbot-ui-backend.store.test.ts

@@ -67,14 +67,14 @@ describe('[ChatbotUiBackendStore]', () => {
 
         test('should subscribe on external events', () => {
             store.subscribe();
-            expect(spyOn).toHaveBeenCalledTimes(7);
-            expect(spyOff).toHaveBeenCalledTimes(7);
+            expect(spyOn).toHaveBeenCalledTimes(8);
+            expect(spyOff).toHaveBeenCalledTimes(8);
         });
 
         test('should unsubscribe from external events', () => {
             store.unsubscribe();
             expect(chatUiStore.on).toHaveBeenCalledTimes(0);
-            expect(chatUiStore.off).toHaveBeenCalledTimes(7);
+            expect(chatUiStore.off).toHaveBeenCalledTimes(8);
         });
     });
 
@@ -259,6 +259,70 @@ describe('[ChatbotUiBackendStore]', () => {
             });
         });
 
+        describe('with session start', () => {
+            const createSession = (id: number) =>
+                ModelsMocks.mockSession({
+                    id,
+                    data: { custom: 'data' },
+                });
+
+            test('should start session', async () => {
+                chatbotApi.postSession.mockResolvedValue(createSession(1));
+                const { session } = await runChatUiEventListener(store.handleSessionStart, [
+                    { custom: 'data' },
+                ]);
+
+                expect(session).toEqual(createSession(1));
+                expect(chatbotApi.postSession).toHaveBeenCalledWith(
+                    { custom: 'data' },
+                    expect.any(AbortSignal)
+                );
+            });
+
+            test('should handle multiple calls', async () => {
+                chatbotApi.postSession.mockResolvedValue(createSession(1));
+                const p1 = runChatUiEventListener(store.handleSessionStart, [{ custom: 'data' }]);
+                const p2 = runChatUiEventListener(store.handleSessionStart, [{ custom: 'data' }]);
+
+                const [r1, r2] = await Promise.all([p1, p2]);
+
+                expect(r1.session).toEqual(createSession(1));
+                expect(r2.session).toEqual(createSession(1));
+                expect(chatbotApi.postSession).toHaveBeenCalledTimes(1);
+                expect(chatbotApi.postSession).toHaveBeenCalledWith(
+                    { custom: 'data' },
+                    expect.any(AbortSignal)
+                );
+            });
+
+            test('should handle forced calls', async () => {
+                chatbotApi.postSession.mockResolvedValue(createSession(1));
+                const { session } = await runChatUiEventListener(store.handleSessionStart, [
+                    { custom: 'data' },
+                ]);
+
+                chatbotApi.postSession.mockResolvedValue(createSession(2));
+                const { session: session2 } = await runChatUiEventListener(
+                    store.handleSessionStart,
+                    [{ custom: 'data' }]
+                );
+                expect(chatbotApi.postSession).toHaveBeenCalledTimes(1);
+                expect(session?.id).toEqual(1);
+                expect(session2?.id).toEqual(1);
+                expect(session === session2).toBe(true);
+
+                // Make api call return another session object and ensure that after
+                chatbotApi.postSession.mockResolvedValue(createSession(3));
+                const { session: session3 } = await runChatUiEventListener(
+                    store.handleSessionStart,
+                    [{ custom: 'data' }, true]
+                );
+                expect(chatbotApi.postSession).toHaveBeenCalledTimes(2);
+                expect(session3?.id).toEqual(3);
+                expect(session === session3).toBe(false);
+            });
+        });
+
         describe('with session feedback', () => {
             const createSessionFeedback = () =>
                 ModelsMocks.mockFeedback({

package/src/stores/__tests__/chatbot-ui.store.test.ts

@@ -57,6 +57,27 @@ describe('[ChatbotUiStore]', () => {
     });
 
     describe('with chat events', () => {
+        test('should startSession', async () => {
+            mockEmit();
+            mockEventEmitter.emit.mockImplementation(
+                async (eventName: string, resolve: (session: Models.ISession) => void) => {
+                    await Promise.resolve();
+                    resolve(ModelsMocks.mockSession());
+                }
+            );
+            const sessionData = ModelsMocks.mockSession({ id: 1 });
+            const session = await store.startSession(sessionData, true);
+            expect(session).toBeDefined();
+            expect(session?.id).toBe(1);
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatbotUiEvent.eventChatbotSessionStart,
+                expect.any(Function),
+                expect.any(Function),
+                sessionData,
+                true
+            );
+        });
+
         test('should sendSessionFeedback', async () => {
             mockEmit();
             const feedback = new Models.Feedback({

package/src/stores/chatbot-ui-backend.store.ts

@@ -59,6 +59,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         this.chatUiStore.on(ChatUiEvent.eventRestart, this.handleRestart);
         this.chatUiStore.on(ChatUiEvent.eventMessageSend, this.handleMessageSend);
         this.chatUiStore.on(ChatUiEvent.eventMessageSendRetry, this.handleMessageSendRetry);
+        this.chatUiStore.on(ChatbotUiEvent.eventChatbotSessionStart, this.handleSessionStart);
         this.chatUiStore.on(ChatbotUiEvent.eventChatbotSessionFeedback, this.handleSessionFeedback);
         this.chatUiStore.on(ChatbotUiEvent.eventChatbotMessageFeedback, this.handleMessageFeedback);
     }
@@ -68,6 +69,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         this.chatUiStore.off(ChatUiEvent.eventRestart, this.handleRestart);
         this.chatUiStore.off(ChatUiEvent.eventMessageSend, this.handleMessageSend);
         this.chatUiStore.off(ChatUiEvent.eventMessageSendRetry, this.handleMessageSendRetry);
+        this.chatUiStore.off(ChatbotUiEvent.eventChatbotSessionStart, this.handleSessionStart);
         this.chatUiStore.off(
             ChatbotUiEvent.eventChatbotSessionFeedback,
             this.handleSessionFeedback
@@ -119,6 +121,15 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         resolve();
     };
 
+    handleSessionStart: ChatUiEventListener<{
+        session?: Models.ISession;
+    }> = async (resolve, _, sessionData?: Models.ISession, forceRecreate?: boolean) => {
+        const session = await this.startSession(sessionData, forceRecreate);
+        resolve({
+            session,
+        });
+    };
+
     handleSessionFeedback: ChatUiEventListener<{
         state: Models.ChatbotFeedbackState;
         feedback?: Models.Feedback;
@@ -136,7 +147,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
                     recoverStrategy: false,
                 });
             }
-            await this.ensureSession();
+            await this.startSession();
             runInAction(() => {
                 feedback.sessionId = this.session!.id;
             });
@@ -174,7 +185,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
                     recoverStrategy: false,
                 });
             }
-            await this.ensureSession();
+            await this.startSession();
             runInAction(() => {
                 feedback.sessionId = this.session!.id;
             });
@@ -265,7 +276,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
 
     private async sendMessage(messageModel: ChatMessageModelText, selections?: Models.Selections) {
         try {
-            await this.ensureSession();
+            await this.startSession();
             this.chatUiStore.setAgentTyping(true);
             const answer = await withTimeout(
                 this.api(
@@ -314,12 +325,20 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         this.session = session;
     }
 
-    private async ensureSession() {
+    private async startSession(sessionData?: Models.ISession, forceRecreate = false) {
+        if (forceRecreate) {
+            this.reset();
+            this.sessionPromise = undefined;
+        }
         if (this.session) {
-            return;
+            return this.session;
         }
         if (!this.sessionPromise) {
-            this.sessionPromise = this.api('postSession', ModelsUtils.createNewSessionModel());
+            this.sessionPromise = this.api(
+                'postSession',
+                ModelsUtils.createNewSessionModel(sessionData),
+                this.abortController.signal
+            );
             const session = await this.sessionPromise;
             this.setSession(session);
             this.withSaveState(() => {
@@ -331,6 +350,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         } finally {
             this.sessionPromise = undefined;
         }
+        return this.session;
     }
 
     private async api<

package/src/stores/chatbot-ui.store.ts

@@ -8,6 +8,7 @@ import { FilterStore } from './filter.store';
 export const CHATBOT_UI_STORE_TOKEN = symbolToken<IChatbotUiStore>('CHATBOT_UI_STORE_TOKEN');
 
 export enum ChatbotUiEvent {
+    eventChatbotSessionStart = 'eventChatbotSessionStart',
     eventChatbotSessionFeedback = 'eventChatbotSessionFeedback',
     eventChatbotMessageFeedback = 'eventChatbotMessageFeedback',
 }
@@ -16,13 +17,17 @@ export interface IChatbotUiStore extends IChatUiStore<ChatbotCustomizations> {
     filterStore: FilterStore;
     settings?: Models.IFrontendModel;
     setFilters: (filterOptions: Models.IFrontendModel) => void;
+    startSession: (
+        sessionData?: Models.ISession,
+        forceRecreate?: boolean
+    ) => Promise<undefined | Models.Session>;
     sendSessionFeedback: (
         feedback: Models.IFeedback
-    ) => Promise<void | Models.ChatbotFeedbackState>;
+    ) => Promise<undefined | Models.ChatbotFeedbackState>;
     sendMessageFeedback: (
         message: Models.IBotMessageWithFeedback,
         messageFeedback: Models.IFeedback
-    ) => Promise<void | Models.ChatbotFeedbackState>;
+    ) => Promise<undefined | Models.ChatbotFeedbackState>;
 }
 
 @injectable()
@@ -58,6 +63,16 @@ export class ChatbotUiStore extends ChatUiStore<ChatbotCustomizations> implement
         this.filterStore.initFilters(filterOptions);
     }
 
+    @action
+    async startSession(sessionData?: Models.ISession, forceRecreate?: boolean) {
+        const result = await this.emitAsync<Models.Session>(
+            ChatbotUiEvent.eventChatbotSessionStart,
+            sessionData,
+            forceRecreate
+        );
+        return result;
+    }
+
     @action
     async sendSessionFeedback(feedback: Models.Feedback) {
         feedback.messageId = undefined; // Ensure messageId is not set for session feedback