@servicetitan/titan-chatbot-api 7.1.1 → 8.0.0

package/dist/stores/__tests__/chatbot-ui-backend.store.test.js

@@ -1,50 +1,43 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 import { expect } from '@jest/globals';
 import { Log } from '@servicetitan/log-service';
-import { ChatError, ChatRunState, } from '@servicetitan/titan-chat-ui-common';
+import { ChatError, ChatRunState } from '@servicetitan/titan-chat-ui-common';
 import { CHATBOT_API_CLIENT, Models, ModelsMocks } from '../../api-client';
 import { ChatbotApiClientMock } from '../../api-client/__mocks__/chatbot-api-client.mock';
 import { initTestContainer } from '../../utils/test-utils';
 import { ChatbotUiBackendStore } from '../chatbot-ui-backend.store';
 import { CHATBOT_UI_STORE_TOKEN, ChatbotUiStore } from '../chatbot-ui.store';
 const WELCOME_MESSAGE = 'Hi there! I’m Agent, an AI chatbot powered by Titan Intelligence. I’m here to answer your questions about using ServiceTitan. You can ask me things like "How to merge duplicate customers?". Do you have a question for me?';
-const initContainer = initTestContainer(ChatbotUiBackendStore, container => {
-    container
-        .bind(Log)
-        .to(class {
-        constructor() {
-            Object.defineProperty(this, "error", {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: jest.fn()
-            });
-            Object.defineProperty(this, "info", {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: jest.fn()
-            });
-            Object.defineProperty(this, "warning", {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: jest.fn()
-            });
+const initContainer = initTestContainer(ChatbotUiBackendStore, (container)=>{
+    container.bind(Log).to(class {
+        constructor(){
+            _define_property(this, "error", jest.fn());
+            _define_property(this, "info", jest.fn());
+            _define_property(this, "warning", jest.fn());
         }
-    })
-        .inSingletonScope();
-    container
-        .bind(CHATBOT_API_CLIENT)
-        .toConstantValue(new ChatbotApiClientMock());
+    }).inSingletonScope();
+    container.bind(CHATBOT_API_CLIENT).toConstantValue(new ChatbotApiClientMock());
     container.bind(CHATBOT_UI_STORE_TOKEN).to(ChatbotUiStore).inSingletonScope();
 });
-describe('[ChatbotUiBackendStore]', () => {
+describe('[ChatbotUiBackendStore]', ()=>{
     let container;
     let store;
     let chatbotApi;
     let chatUiStore;
     let log;
-    beforeEach(() => {
+    beforeEach(()=>{
         container = initContainer();
         store = container.get(ChatbotUiBackendStore);
         chatbotApi = container.get(CHATBOT_API_CLIENT);
@@ -53,63 +46,69 @@ describe('[ChatbotUiBackendStore]', () => {
         jest.useFakeTimers();
         jest.setSystemTime(new Date('2000-01-01T00:00:00.000Z'));
     });
-    afterEach(() => {
+    afterEach(()=>{
         jest.useRealTimers();
         jest.clearAllMocks();
     });
-    describe('with subscription', () => {
+    describe('with subscription', ()=>{
         let spyOn;
         let spyOff;
-        beforeEach(() => {
+        beforeEach(()=>{
             spyOn = jest.spyOn(chatUiStore, 'on');
             spyOff = jest.spyOn(chatUiStore, 'off');
         });
-        test('should subscribe on external events', () => {
+        test('should subscribe on external events', ()=>{
             store.subscribe();
             expect(spyOn).toHaveBeenCalledTimes(8);
             expect(spyOff).toHaveBeenCalledTimes(8);
         });
-        test('should unsubscribe from external events', () => {
+        test('should unsubscribe from external events', ()=>{
             store.unsubscribe();
             expect(chatUiStore.on).toHaveBeenCalledTimes(0);
             expect(chatUiStore.off).toHaveBeenCalledTimes(8);
         });
     });
-    describe('with run', () => {
-        const runChatUiEventListener = async (listener, args) => {
-            return new Promise((resolve, reject) => {
-                listener.apply(store, [resolve, reject, ...args]);
+    describe('with run', ()=>{
+        const runChatUiEventListener = async (listener, args)=>{
+            return new Promise((resolve, reject)=>{
+                listener.apply(store, [
+                    resolve,
+                    reject,
+                    ...args
+                ]);
             });
         };
-        const runStore = async () => {
+        const runStore = async ()=>{
             await runChatUiEventListener(store.handleRun, []);
             await jest.advanceTimersToNextTimerAsync(); // Wait for the timer to be set
         };
-        const mockChatbotSession = () => {
+        const mockChatbotSession = ()=>{
             chatbotApi.getOptions.mockResolvedValue(ModelsMocks.mockFrontendModel());
             chatbotApi.postSession.mockResolvedValue(ModelsMocks.mockSession());
             chatbotApi.deleteSession.mockResolvedValue(ModelsMocks.mockSession());
         };
-        const mockChatbotAnswer = (answer) => {
+        const mockChatbotAnswer = (answer)=>{
             const answerMock = ModelsMocks.mockBotMessage({
                 id: 123,
-                answer,
+                answer
             });
             chatbotApi.postMessage.mockResolvedValue(answerMock);
             return answerMock;
         };
-        const mockChatbotAnswers = (answers) => {
-            const answerMocks = answers.map(({ answer, answerId }, index) => ModelsMocks.mockBotMessage({
-                id: answerId !== null && answerId !== void 0 ? answerId : 123 + index,
-                answer,
-            }));
+        const mockChatbotAnswers = (answers)=>{
+            const answerMocks = answers.map(({ answer, answerId }, index)=>ModelsMocks.mockBotMessage({
+                    id: answerId !== null && answerId !== void 0 ? answerId : 123 + index,
+                    answer
+                }));
             // Mock in reverse order to simulate responses coming back in different order
-            [...answerMocks].reverse().forEach(mock => {
+            [
+                ...answerMocks
+            ].reverse().forEach((mock)=>{
                 chatbotApi.postMessage.mockResolvedValueOnce(mock);
             });
             return answerMocks;
         };
-        const ensureChatStarted = () => {
+        const ensureChatStarted = ()=>{
             expect(chatUiStore.isAgentTyping).toBe(false);
             expect(chatUiStore.isFilePickerEnabled).toBe(false);
             expect(chatUiStore.file).toBe(undefined);
@@ -120,7 +119,7 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(chatUiStore.scrollCounter > 1).toBe(true);
             expect(chatUiStore.status).toBe(ChatRunState.Started);
         };
-        test('should run chatbot without stored session', async () => {
+        test('should run chatbot without stored session', async ()=>{
             store.subscribe();
             mockChatbotSession();
             await runStore();
@@ -131,8 +130,7 @@ describe('[ChatbotUiBackendStore]', () => {
             /*
              * We don't have session yet because we've just initialized the chat with welcome message
              * and we don't do any chatbotApi.postSession call
-             */
-            expect(store.session).toBeUndefined();
+             */ expect(store.session).toBeUndefined();
             expect(chatbotApi.postSession).toHaveBeenCalledTimes(0);
             const botAnswer = mockChatbotAnswer('bot answer');
             await chatUiStore.sendMessageText('user question');
@@ -147,7 +145,7 @@ describe('[ChatbotUiBackendStore]', () => {
             // Ensure that question data contains answerId from bot answer
             expect(question.data).toEqual({
                 answerId: botAnswer.id,
-                selections: undefined,
+                selections: undefined
             });
             expect(answer.type).toBe('message');
             expect(answer.participant.isAgent).toBe(true);
@@ -155,32 +153,38 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(answer.data).toEqual(botAnswer);
             expect(log.error).toHaveBeenCalledTimes(0);
         });
-        test('should have correct answer ids in user messages for simultaneous messages', async () => {
+        test('should have correct answer ids in user messages for simultaneous messages', async ()=>{
             store.subscribe();
             mockChatbotSession();
             await runStore();
             ensureChatStarted();
             expect(chatUiStore.messages.length).toBe(1);
             const [botAnswer1, botAnswer2] = mockChatbotAnswers([
-                { answer: 'bot answer 1', answerId: 111 },
-                { answer: 'bot answer 2', answerId: 222 },
+                {
+                    answer: 'bot answer 1',
+                    answerId: 111
+                },
+                {
+                    answer: 'bot answer 2',
+                    answerId: 222
+                }
             ]);
             await Promise.all([
                 chatUiStore.sendMessageText('user question 1'),
-                chatUiStore.sendMessageText('user question 2'),
+                chatUiStore.sendMessageText('user question 2')
             ]);
             expect(chatUiStore.messages.length).toBe(5);
             const textMessages = chatUiStore.messages;
-            const question1 = textMessages.find(x => x.message === 'user question 1');
-            const answer1 = textMessages.find(x => x.message === 'bot answer 1');
-            const question2 = textMessages.find(x => x.message === 'user question 2');
-            const answer2 = textMessages.find(x => x.message === 'bot answer 2');
+            const question1 = textMessages.find((x)=>x.message === 'user question 1');
+            const answer1 = textMessages.find((x)=>x.message === 'bot answer 1');
+            const question2 = textMessages.find((x)=>x.message === 'user question 2');
+            const answer2 = textMessages.find((x)=>x.message === 'bot answer 2');
             expect(question1.type).toBe('message');
             expect(question1.participant.isAgent).toBe(false);
             expect(question1.message).toBe('user question 1');
             expect(question1.data).toEqual({
                 answerId: botAnswer1.id,
-                selections: undefined,
+                selections: undefined
             });
             expect(answer1.type).toBe('message');
             expect(answer1.participant.isAgent).toBe(true);
@@ -191,7 +195,7 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(question2.message).toBe('user question 2');
             expect(question2.data).toEqual({
                 answerId: botAnswer2.id,
-                selections: undefined,
+                selections: undefined
             });
             expect(answer2.type).toBe('message');
             expect(answer2.participant.isAgent).toBe(true);
@@ -199,7 +203,7 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(answer2.data).toEqual(botAnswer2);
             expect(log.error).toHaveBeenCalledTimes(0);
         });
-        test('should run chatbot with stored session with expiration', async () => {
+        test('should run chatbot with stored session with expiration', async ()=>{
             mockChatbotSession();
             await jest.advanceTimersByTimeAsync(1000 * 60 * 60 * 16);
             await runStore();
@@ -209,7 +213,7 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(chatbotApi.postSession).toHaveBeenCalledTimes(0);
             expect(log.error).toHaveBeenCalledTimes(0);
         });
-        test('should destroy', async () => {
+        test('should destroy', async ()=>{
             mockChatbotSession();
             await runStore();
             store.session = ModelsMocks.mockSession();
@@ -220,7 +224,7 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(store.session).toBeUndefined();
             expect(log.error).toHaveBeenCalledTimes(0);
         });
-        test('should restart', async () => {
+        test('should restart', async ()=>{
             mockChatbotSession();
             await runStore();
             store.session = ModelsMocks.mockSession();
@@ -230,26 +234,30 @@ describe('[ChatbotUiBackendStore]', () => {
             expect(chatUiStore.status).toBe(ChatRunState.Started);
             expect(log.error).toHaveBeenCalledTimes(0);
         });
-        describe('with messages', () => {
-            test('should send message', async () => {
+        describe('with messages', ()=>{
+            test('should send message', async ()=>{
                 mockChatbotSession();
                 mockChatbotAnswer('bot answer');
                 await runStore();
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
-                await runChatUiEventListener(store.handleMessageSend, [message]);
+                await runChatUiEventListener(store.handleMessageSend, [
+                    message
+                ]);
                 expect(chatUiStore.messages.length).toBe(3);
                 expect(chatUiStore.messages[0].message).toBe(WELCOME_MESSAGE);
                 expect(chatUiStore.messages[1].message).toBe('user question');
                 expect(chatUiStore.messages[2].message).toBe('bot answer');
                 expect(log.error).toHaveBeenCalledTimes(0);
             });
-            test('should send message with error', async () => {
+            test('should send message with error', async ()=>{
                 mockChatbotSession();
                 chatbotApi.postMessage.mockRejectedValue(new Error('error'));
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
-                await runChatUiEventListener(store.handleMessageSend, [message]);
+                await runChatUiEventListener(store.handleMessageSend, [
+                    message
+                ]);
                 expect(chatbotApi.postSession).toHaveBeenCalled();
                 expect(chatbotApi.postMessage).toHaveBeenCalled();
                 expect(chatUiStore.isError).toBe(true);
@@ -257,61 +265,85 @@ describe('[ChatbotUiBackendStore]', () => {
                     category: 'TitanChatbot',
                     code: 'TitanChatbot_FailedToSendMessage',
                     error: new Error('error'),
-                    message: 'Failed to send message',
+                    message: 'Failed to send message'
                 });
             });
-            test('should use per-request timeoutMs when provided', async () => {
+            test('should use per-request timeoutMs when provided', async ()=>{
                 mockChatbotSession();
-                chatbotApi.postMessage.mockImplementation(() => new Promise(resolve => setTimeout(() => resolve(ModelsMocks.mockBotMessage({ answer: 'late answer' })), 200)));
+                chatbotApi.postMessage.mockImplementation(()=>new Promise((resolve)=>setTimeout(()=>resolve(ModelsMocks.mockBotMessage({
+                                answer: 'late answer'
+                            })), 200)));
                 await runStore();
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
-                const p = runChatUiEventListener(store.handleMessageSend, [message, undefined, 50]);
+                const p = runChatUiEventListener(store.handleMessageSend, [
+                    message,
+                    undefined,
+                    50
+                ]);
                 await jest.advanceTimersByTimeAsync(50);
                 await p;
                 expect(chatUiStore.isError).toBe(true);
                 expect(log.error).toHaveBeenCalledWith(expect.objectContaining({
                     code: 'TitanChatbot_FailedToSendMessage',
-                    message: 'Failed to send message',
+                    message: 'Failed to send message'
                 }));
             });
-            test('should fall back to global timeout when no per-request timeoutMs', async () => {
+            test('should fall back to global timeout when no per-request timeoutMs', async ()=>{
                 mockChatbotSession();
-                chatbotApi.postMessage.mockImplementation(() => new Promise(resolve => setTimeout(() => resolve(ModelsMocks.mockBotMessage({ answer: 'late answer' })), 200)));
-                chatUiStore.setCustomizationContext({ timeouts: { chatbotRequestTimeoutMs: 100 } });
+                chatbotApi.postMessage.mockImplementation(()=>new Promise((resolve)=>setTimeout(()=>resolve(ModelsMocks.mockBotMessage({
+                                answer: 'late answer'
+                            })), 200)));
+                chatUiStore.setCustomizationContext({
+                    timeouts: {
+                        chatbotRequestTimeoutMs: 100
+                    }
+                });
                 await runStore();
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
                 // No per-request timeoutMs — should use global (100ms)
-                const p = runChatUiEventListener(store.handleMessageSend, [message, undefined]);
+                const p = runChatUiEventListener(store.handleMessageSend, [
+                    message,
+                    undefined
+                ]);
                 await jest.advanceTimersByTimeAsync(100);
                 await p;
                 expect(chatUiStore.isError).toBe(true);
-                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ code: 'TitanChatbot_FailedToSendMessage' }));
+                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({
+                    code: 'TitanChatbot_FailedToSendMessage'
+                }));
             });
-            test('should fall back to DEFAULT timeout when neither per-request nor global timeout is set', async () => {
+            test('should fall back to DEFAULT timeout when neither per-request nor global timeout is set', async ()=>{
                 mockChatbotSession();
-                chatbotApi.postMessage.mockImplementation(() => new Promise(resolve => setTimeout(() => resolve(ModelsMocks.mockBotMessage({ answer: 'late answer' })), 40000)));
+                chatbotApi.postMessage.mockImplementation(()=>new Promise((resolve)=>setTimeout(()=>resolve(ModelsMocks.mockBotMessage({
+                                answer: 'late answer'
+                            })), 40000)));
                 await runStore();
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
                 // No per-request timeoutMs, no global timeout — should use DEFAULT (31000ms)
-                const p = runChatUiEventListener(store.handleMessageSend, [message, undefined]);
+                const p = runChatUiEventListener(store.handleMessageSend, [
+                    message,
+                    undefined
+                ]);
                 await jest.runOnlyPendingTimersAsync();
                 await p;
                 expect(chatUiStore.isError).toBe(true);
-                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ code: 'TitanChatbot_FailedToSendMessage' }));
+                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({
+                    code: 'TitanChatbot_FailedToSendMessage'
+                }));
             });
-            test('should not abort store-level controller when per-request timeout fires', async () => {
+            test('should not abort store-level controller when per-request timeout fires', async ()=>{
                 mockChatbotSession();
                 /*
                  * First message: slow — will time out at 50ms
                  * Second message: fast — should succeed despite the first timing out
-                 */
-                const fastAnswer = ModelsMocks.mockBotMessage({ answer: 'fast answer' });
-                chatbotApi.postMessage
-                    .mockImplementationOnce(() => new Promise(() => { })) // never resolves — times out
-                    .mockResolvedValueOnce(fastAnswer);
+                 */ const fastAnswer = ModelsMocks.mockBotMessage({
+                    answer: 'fast answer'
+                });
+                chatbotApi.postMessage.mockImplementationOnce(()=>new Promise(()=>{})) // never resolves — times out
+                .mockResolvedValueOnce(fastAnswer);
                 await runStore();
                 await chatUiStore.sendMessageText('slow question');
                 const slowMessage = chatUiStore.messages.at(-1);
@@ -319,7 +351,7 @@ describe('[ChatbotUiBackendStore]', () => {
                 const p1 = runChatUiEventListener(store.handleMessageSend, [
                     slowMessage,
                     undefined,
-                    50,
+                    50
                 ]);
                 await jest.advanceTimersByTimeAsync(50);
                 await p1;
@@ -329,15 +361,19 @@ describe('[ChatbotUiBackendStore]', () => {
                 chatUiStore.resetError(ChatRunState.Started);
                 await chatUiStore.sendMessageText('fast question');
                 const fastMessage = chatUiStore.messages.at(-1);
-                await runChatUiEventListener(store.handleMessageSend, [fastMessage]);
+                await runChatUiEventListener(store.handleMessageSend, [
+                    fastMessage
+                ]);
                 expect(chatUiStore.isError).toBe(false);
                 expect(chatUiStore.messages.at(-1)).toMatchObject({
-                    message: 'fast answer',
+                    message: 'fast answer'
                 });
             });
-            test('should preserve per-request timeoutMs on retry', async () => {
+            test('should preserve per-request timeoutMs on retry', async ()=>{
                 mockChatbotSession();
-                chatbotApi.postMessage.mockImplementation(() => new Promise(resolve => setTimeout(() => resolve(ModelsMocks.mockBotMessage({ answer: 'late answer' })), 200)));
+                chatbotApi.postMessage.mockImplementation(()=>new Promise((resolve)=>setTimeout(()=>resolve(ModelsMocks.mockBotMessage({
+                                answer: 'late answer'
+                            })), 200)));
                 await runStore();
                 await chatUiStore.sendMessageText('user question');
                 const message = chatUiStore.messages.at(-1);
@@ -345,110 +381,155 @@ describe('[ChatbotUiBackendStore]', () => {
                 const p1 = runChatUiEventListener(store.handleMessageSend, [
                     message,
                     undefined,
-                    50,
+                    50
                 ]);
                 await jest.advanceTimersByTimeAsync(50);
                 await p1;
                 expect(chatUiStore.isError).toBe(true);
                 // Retry should reuse the persisted timeoutMs (50ms), not fall back to default (31000ms)
-                chatbotApi.postMessage.mockImplementation(() => new Promise(resolve => setTimeout(() => resolve(ModelsMocks.mockBotMessage({ answer: 'late answer' })), 200)));
-                const p2 = runChatUiEventListener(store.handleMessageSendRetry, [message]);
+                chatbotApi.postMessage.mockImplementation(()=>new Promise((resolve)=>setTimeout(()=>resolve(ModelsMocks.mockBotMessage({
+                                answer: 'late answer'
+                            })), 200)));
+                const p2 = runChatUiEventListener(store.handleMessageSendRetry, [
+                    message
+                ]);
                 await jest.advanceTimersByTimeAsync(50);
                 await p2;
                 // If retry had fallen back to default 31000ms, it would not have timed out in 50ms
-                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ code: 'TitanChatbot_FailedToSendMessage' }));
+                expect(log.error).toHaveBeenCalledWith(expect.objectContaining({
+                    code: 'TitanChatbot_FailedToSendMessage'
+                }));
             });
-            test('should send message retry', async () => {
+            test('should send message retry', async ()=>{
                 mockChatbotSession();
                 const spyMessage = jest.spyOn(chatbotApi, 'postMessage');
                 // Retry with non-text message should not call "message"
                 const messageNonText = ModelsMocks.mockChatMessageModel({
-                    type: 'welcome',
+                    type: 'welcome'
                 });
-                await runChatUiEventListener(store.handleMessageSendRetry, [messageNonText]);
+                await runChatUiEventListener(store.handleMessageSendRetry, [
+                    messageNonText
+                ]);
                 expect(spyMessage).not.toHaveBeenCalled();
                 // Retry with text message should call "message"
                 const message = ModelsMocks.mockChatMessageModel({
-                    message: 'message',
+                    message: 'message'
                 });
-                await runChatUiEventListener(store.handleMessageSendRetry, [message]);
+                await runChatUiEventListener(store.handleMessageSendRetry, [
+                    message
+                ]);
                 expect(spyMessage).toHaveBeenCalledWith(ModelsMocks.mockUserMessage({
                     context: undefined,
                     selections: undefined,
-                    question: 'message',
+                    question: 'message'
                 }), expect.any(AbortSignal));
             });
         });
-        describe('with session start', () => {
-            const createSession = (id) => ModelsMocks.mockSession({
-                id,
-                data: { custom: 'data' },
-            });
-            test('should start session', async () => {
+        describe('with session start', ()=>{
+            const createSession = (id)=>ModelsMocks.mockSession({
+                    id,
+                    data: {
+                        custom: 'data'
+                    }
+                });
+            test('should start session', async ()=>{
                 const spyGetData = jest.spyOn(store, 'getSessionData').mockResolvedValue({
-                    defaultData: 'defaultData',
+                    defaultData: 'defaultData'
                 });
                 chatbotApi.postSession.mockResolvedValue(createSession(1));
                 const { session } = await runChatUiEventListener(store.handleSessionStart, [
-                    { custom: 'data' },
+                    {
+                        custom: 'data'
+                    }
                 ]);
                 expect(spyGetData).toHaveBeenCalled();
                 expect(session).toEqual(createSession(1));
                 expect(chatbotApi.postSession).toHaveBeenCalledWith({
-                    data: { custom: 'data', defaultData: 'defaultData' },
+                    data: {
+                        custom: 'data',
+                        defaultData: 'defaultData'
+                    }
                 }, expect.any(AbortSignal));
             });
-            test('should handle multiple calls', async () => {
+            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]);
+                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({
-                    data: { custom: 'data' },
+                    data: {
+                        custom: 'data'
+                    }
                 }, expect.any(AbortSignal));
             });
-            test('should handle forced calls', async () => {
+            test('should handle forced calls', async ()=>{
                 chatbotApi.postSession.mockResolvedValue(createSession(1));
                 const { session } = await runChatUiEventListener(store.handleSessionStart, [
-                    { custom: 'data' },
+                    {
+                        custom: 'data'
+                    }
                 ]);
                 chatbotApi.postSession.mockResolvedValue(createSession(2));
-                const { session: session2 } = await runChatUiEventListener(store.handleSessionStart, [{ custom: 'data' }]);
+                const { session: session2 } = await runChatUiEventListener(store.handleSessionStart, [
+                    {
+                        custom: 'data'
+                    }
+                ]);
                 expect(chatbotApi.postSession).toHaveBeenCalledTimes(1);
                 expect(session === null || session === void 0 ? void 0 : session.id).toEqual(1);
                 expect(session2 === null || session2 === void 0 ? void 0 : 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]);
+                const { session: session3 } = await runChatUiEventListener(store.handleSessionStart, [
+                    {
+                        custom: 'data'
+                    },
+                    true
+                ]);
                 expect(chatbotApi.postSession).toHaveBeenCalledTimes(2);
                 expect(session3 === null || session3 === void 0 ? void 0 : session3.id).toEqual(3);
                 expect(session === session3).toBe(false);
             });
         });
-        describe('with session feedback', () => {
-            const createSessionFeedback = () => ModelsMocks.mockFeedback({
-                sessionId: 1,
-                messageId: undefined,
-                rating: Models.FeedbackRatings.ThumbsUp,
-                description: 'description',
-            });
-            test('should send feedback', async () => {
+        describe('with session feedback', ()=>{
+            const createSessionFeedback = ()=>ModelsMocks.mockFeedback({
+                    sessionId: 1,
+                    messageId: undefined,
+                    rating: Models.FeedbackRatings.ThumbsUp,
+                    description: 'description'
+                });
+            test('should send feedback', async ()=>{
                 mockChatbotSession();
                 chatbotApi.postFeedback.mockResolvedValueOnce(createSessionFeedback());
-                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [createSessionFeedback()]);
+                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [
+                    createSessionFeedback()
+                ]);
                 expect(state).toBe(Models.ChatbotFeedbackState.Success);
                 expect(feedback).toEqual(createSessionFeedback());
                 expect(chatbotApi.postSession).toHaveBeenCalled();
                 expect(chatbotApi.postFeedback).toHaveBeenCalledWith(createSessionFeedback(), expect.any(AbortSignal));
             });
-            test('should send feedback with session error', async () => {
+            test('should send feedback with session error', async ()=>{
                 chatbotApi.postSession.mockRejectedValueOnce('session error');
                 chatbotApi.postFeedback.mockResolvedValueOnce(createSessionFeedback());
-                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [createSessionFeedback()]);
+                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [
+                    createSessionFeedback()
+                ]);
                 expect(state).toBe(Models.ChatbotFeedbackState.Failure);
                 expect(feedback).toEqual(createSessionFeedback());
                 expect(chatbotApi.postSession).toHaveBeenCalled();
@@ -458,14 +539,16 @@ describe('[ChatbotUiBackendStore]', () => {
                     category: 'TitanChatbot',
                     code: 'TitanChatbot_FailedToSendFeedback',
                     error: 'session error',
-                    message: 'Failed to send feedback',
+                    message: 'Failed to send feedback'
                 });
             });
-            test('should send feedback with error', async () => {
+            test('should send feedback with error', async ()=>{
                 mockChatbotSession();
                 chatbotApi.postSession.mockReset().mockRejectedValue(new Error('session error'));
                 chatbotApi.postFeedback.mockResolvedValueOnce(createSessionFeedback());
-                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [createSessionFeedback()]);
+                const { feedback, state } = await runChatUiEventListener(store.handleSessionFeedback, [
+                    createSessionFeedback()
+                ]);
                 expect(state).toBe(Models.ChatbotFeedbackState.Failure);
                 expect(feedback).toEqual(createSessionFeedback());
                 expect(chatbotApi.postSession).toHaveBeenCalled();
@@ -475,82 +558,94 @@ describe('[ChatbotUiBackendStore]', () => {
                     category: 'TitanChatbot',
                     code: 'TitanChatbot_FailedToSendFeedback',
                     error: new Error('session error'),
-                    message: 'Failed to send feedback',
+                    message: 'Failed to send feedback'
                 });
             });
         });
-        describe('with message feedback', () => {
-            const createMessageFeedback = () => ModelsMocks.mockFeedback({
-                sessionId: 1,
-                messageId: 1,
-                description: 'description',
-                linkUrl: 'linkUrl',
-                options: [Models.FeedbackOptions.Unclear, Models.FeedbackOptions.Incorrect],
-                rating: Models.FeedbackRatings.ThumbsUp,
-            });
-            const createLogError = (errorMessage) => ({
-                category: 'TitanChatbot',
-                code: 'TitanChatbot_FailedToSendMessageFeedback',
-                error: errorMessage,
-                message: 'Failed to send message feedback',
-            });
-            test('should assert message feedback 1', async () => {
-                var _a;
+        describe('with message feedback', ()=>{
+            const createMessageFeedback = ()=>ModelsMocks.mockFeedback({
+                    sessionId: 1,
+                    messageId: 1,
+                    description: 'description',
+                    linkUrl: 'linkUrl',
+                    options: [
+                        Models.FeedbackOptions.Unclear,
+                        Models.FeedbackOptions.Incorrect
+                    ],
+                    rating: Models.FeedbackRatings.ThumbsUp
+                });
+            const createLogError = (errorMessage)=>({
+                    category: 'TitanChatbot',
+                    code: 'TitanChatbot_FailedToSendMessageFeedback',
+                    error: errorMessage,
+                    message: 'Failed to send message feedback'
+                });
+            test('should assert message feedback 1', async ()=>{
+                var _chatUiStore_error;
                 const { feedback, state } = await runChatUiEventListener(store.handleMessageFeedback, []);
                 expect(feedback).toBeUndefined();
                 expect(state).toBe(Models.ChatbotFeedbackState.Failure);
                 expect(chatUiStore.isError).toBe(true);
-                expect((_a = chatUiStore.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Failed to send message feedback');
+                expect((_chatUiStore_error = chatUiStore.error) === null || _chatUiStore_error === void 0 ? void 0 : _chatUiStore_error.message).toBe('Failed to send message feedback');
                 expect(log.error).toHaveBeenCalledWith({
                     category: 'TitanChatbot',
                     code: 'TitanChatbot_FailedToSendMessageFeedback',
                     error: new ChatError('Message feedback is missing.'),
-                    message: 'Failed to send message feedback',
+                    message: 'Failed to send message feedback'
                 });
                 expect(chatbotApi.postFeedback).not.toHaveBeenCalled();
             });
-            test('should assert message feedback 3', async () => {
-                var _a;
+            test('should assert message feedback 3', async ()=>{
+                var _chatUiStore_error;
                 chatbotApi.postSession.mockRejectedValueOnce('session error');
-                const { feedback, state } = await runChatUiEventListener(store.handleMessageFeedback, [createMessageFeedback()]);
+                const { feedback, state } = await runChatUiEventListener(store.handleMessageFeedback, [
+                    createMessageFeedback()
+                ]);
                 expect(state).toBe(Models.ChatbotFeedbackState.Failure);
                 expect(feedback).toEqual(createMessageFeedback());
                 expect(chatUiStore.isError).toBe(true);
-                expect((_a = chatUiStore.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Failed to send message feedback');
+                expect((_chatUiStore_error = chatUiStore.error) === null || _chatUiStore_error === void 0 ? void 0 : _chatUiStore_error.message).toBe('Failed to send message feedback');
                 expect(log.error).toHaveBeenCalledWith({
                     category: 'TitanChatbot',
                     code: 'TitanChatbot_FailedToSendMessageFeedback',
                     error: 'session error',
-                    message: 'Failed to send message feedback',
+                    message: 'Failed to send message feedback'
                 });
                 expect(chatbotApi.postFeedback).not.toHaveBeenCalled();
             });
-            test('should send message feedback', async () => {
+            test('should send message feedback', async ()=>{
                 mockChatbotSession();
                 chatbotApi.postFeedback.mockResolvedValueOnce(createMessageFeedback());
                 const feedback = createMessageFeedback();
-                await runChatUiEventListener(store.handleMessageFeedback, [feedback]);
+                await runChatUiEventListener(store.handleMessageFeedback, [
+                    feedback
+                ]);
                 expect(chatbotApi.postFeedback).toHaveBeenCalledWith({
-                    ...feedback,
+                    ...feedback
                 }, expect.any(AbortSignal));
             });
-            test('should send message feedback with session error', async () => {
+            test('should send message feedback with session error', async ()=>{
                 chatbotApi.postSession.mockRejectedValueOnce('session error');
                 chatbotApi.postFeedback.mockResolvedValueOnce(createMessageFeedback());
                 const feedback = createMessageFeedback();
-                await runChatUiEventListener(store.handleMessageFeedback, [feedback]);
+                await runChatUiEventListener(store.handleMessageFeedback, [
+                    feedback
+                ]);
                 expect(chatbotApi.postFeedback).not.toHaveBeenCalled();
                 expect(log.error).toHaveBeenCalledWith(createLogError('session error'));
             });
-            test('should send message feedback with feedback error', async () => {
+            test('should send message feedback with feedback error', async ()=>{
                 mockChatbotSession();
                 chatbotApi.postFeedback.mockRejectedValueOnce('feedback error');
                 const feedback = createMessageFeedback();
-                await runChatUiEventListener(store.handleMessageFeedback, [feedback]);
+                await runChatUiEventListener(store.handleMessageFeedback, [
+                    feedback
+                ]);
                 expect(chatbotApi.postFeedback).toHaveBeenCalledTimes(1);
                 expect(log.error).toHaveBeenCalledWith(createLogError('feedback error'));
             });
         });
     });
 });
+
 //# sourceMappingURL=chatbot-ui-backend.store.test.js.map