@servicetitan/titan-chatbot-api 6.0.0 → 6.1.1

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

@@ -318,6 +318,183 @@ describe('[ChatbotUiBackendStore]', () => {
                 });
             });
 
+            test('should use per-request timeoutMs when provided', async () => {
+                mockChatbotSession();
+                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)! as ChatMessageModelText;
+
+                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',
+                    })
+                );
+            });
+
+            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 } });
+
+                await runStore();
+                await chatUiStore.sendMessageText('user question');
+                const message = chatUiStore.messages.at(-1)! as ChatMessageModelText;
+
+                // No per-request timeoutMs — should use global (100ms)
+                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' })
+                );
+            });
+
+            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
+                            )
+                        )
+                );
+
+                await runStore();
+                await chatUiStore.sendMessageText('user question');
+                const message = chatUiStore.messages.at(-1)! as ChatMessageModelText;
+
+                // No per-request timeoutMs, no global timeout — should use DEFAULT (31000ms)
+                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' })
+                );
+            });
+
+            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);
+
+                await runStore();
+
+                await chatUiStore.sendMessageText('slow question');
+                const slowMessage = chatUiStore.messages.at(-1)! as ChatMessageModelText;
+
+                // Start slow message with a short per-request timeout
+                const p1 = runChatUiEventListener(store.handleMessageSend, [
+                    slowMessage,
+                    undefined,
+                    50,
+                ]);
+                await jest.advanceTimersByTimeAsync(50);
+                await p1;
+
+                expect(chatUiStore.isError).toBe(true);
+                expect(store.abortController.signal.aborted).toBe(false); // store-level signal must remain intact
+
+                // A subsequent message should still succeed because the store controller was not aborted
+                chatUiStore.resetError(ChatRunState.Started);
+                await chatUiStore.sendMessageText('fast question');
+                const fastMessage = chatUiStore.messages.at(-1)! as ChatMessageModelText;
+                await runChatUiEventListener(store.handleMessageSend, [fastMessage]);
+
+                expect(chatUiStore.isError).toBe(false);
+                expect(chatUiStore.messages.at(-1)! as ChatMessageModelText).toMatchObject({
+                    message: 'fast answer',
+                });
+            });
+
+            test('should preserve per-request timeoutMs on retry', async () => {
+                mockChatbotSession();
+                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)! as ChatMessageModelText;
+
+                // Initial send fails due to per-request timeout; timeoutMs is persisted on the message
+                const p1 = runChatUiEventListener(store.handleMessageSend, [
+                    message,
+                    undefined,
+                    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]);
+                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' })
+                );
+            });
+
             test('should send message retry', async () => {
                 mockChatbotSession();
                 const spyMessage = jest.spyOn(chatbotApi, 'postMessage');

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

@@ -153,6 +153,24 @@ describe('[ChatbotUiStore]', () => {
             await checkScrollTriggered();
         });
 
+        test('should sendMessageText with timeoutMs option', async () => {
+            mockEmit();
+            const messageText = 'Hello, world!';
+            await store.sendMessageText(messageText, { timeoutMs: 50 });
+
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatUiEvent.eventMessageSend,
+                expect.any(Function),
+                expect.any(Function),
+                expect.objectContaining({
+                    type: 'message',
+                    message: messageText,
+                }),
+                store.filterStore.export(),
+                50
+            );
+        });
+
         test('should sendMessageText without message', async () => {
             mockEmit();
             await store.sendMessageText('');

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

@@ -106,9 +106,10 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
         resolve,
         _,
         messageModel: ChatMessageModelText,
-        selections: Models.Selections | undefined
+        selections: Models.Selections | undefined,
+        timeoutMs?: number
     ) => {
-        await this.sendMessage(messageModel, selections);
+        await this.sendMessage(messageModel, selections, timeoutMs);
         resolve();
     };
 
@@ -122,7 +123,8 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
             return;
         }
         const selections = messageModel.data?.selections as Models.Selections | undefined;
-        await this.sendMessage(messageModel as ChatMessageModelText, selections);
+        const timeoutMs = messageModel.data?.timeoutMs as number | undefined;
+        await this.sendMessage(messageModel as ChatMessageModelText, selections, timeoutMs);
         resolve();
     };
 
@@ -296,9 +298,14 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
 
     protected async sendMessage(
         messageModel: ChatMessageModelText,
-        selections?: Models.Selections
+        selections?: Models.Selections,
+        timeoutMs?: number
     ) {
         const question = messageModel.message;
+        const perRequestController = new AbortController();
+        const forwardStoreAbort = () =>
+            perRequestController.abort(this.abortController.signal.reason);
+        this.abortController.signal.addEventListener('abort', forwardStoreAbort, { once: true });
         try {
             await this.startSession();
             this.chatUiStore.setAgentTyping(true);
@@ -311,11 +318,12 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
                         experience: Models.Experience.MultiTurn,
                         selections,
                     }),
-                    this.abortController.signal
+                    perRequestController.signal
                 ),
-                this.customizations?.timeouts?.chatbotRequestTimeoutMs ??
+                timeoutMs ??
+                    this.customizations?.timeouts?.chatbotRequestTimeoutMs ??
                     DEFAULT_CHATBOT_ASK_BOT_TIMEOUT_MS,
-                this.abortController
+                perRequestController
             );
             this.withSaveState(() => {
                 // Set message state to Delivered and preserve selections and bot answer id to the user question (to have a link between question and answer)
@@ -330,6 +338,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
             this.withSaveState(() => {
                 this.chatUiStore.setMessageState(messageModel, ChatMessageState.Failed, {
                     selections,
+                    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
                 });
             });
             if (error instanceof ChatError) {
@@ -343,6 +352,7 @@ export class ChatbotUiBackendStore extends InitializeStore implements IChatbotUi
                 );
             }
         } finally {
+            this.abortController.signal.removeEventListener('abort', forwardStoreAbort);
             this.chatUiStore.setAgentTyping(false);
         }
     }

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

@@ -16,18 +16,19 @@ export enum ChatbotUiEvent {
 export interface IChatbotUiStore extends IChatUiStore<ChatbotCustomizations> {
     filterStore: IFilterStore;
     settings?: Models.IFrontendModel;
-    setFilters: (filterOptions: Models.IFrontendModel, options?: IFilterStoreInitOptions) => void;
-    startSession: (
+    sendMessageText(messageText: string, options?: { timeoutMs?: number }): Promise<void>;
+    setFilters(filterOptions: Models.IFrontendModel, options?: IFilterStoreInitOptions): void;
+    startSession(
         sessionData?: Models.ISession['data'],
         forceRecreate?: boolean
-    ) => Promise<undefined | Models.Session>;
-    sendSessionFeedback: (
+    ): Promise<undefined | Models.Session>;
+    sendSessionFeedback(
         feedback: Models.IFeedback
-    ) => Promise<undefined | Models.ChatbotFeedbackState>;
-    sendMessageFeedback: (
+    ): Promise<undefined | Models.ChatbotFeedbackState>;
+    sendMessageFeedback(
         message: Models.IBotMessageWithFeedback,
         messageFeedback: Models.IFeedback
-    ) => Promise<undefined | Models.ChatbotFeedbackState>;
+    ): Promise<undefined | Models.ChatbotFeedbackState>;
 }
 
 @injectable()
@@ -49,13 +50,18 @@ export class ChatbotUiStore extends ChatUiStore<ChatbotCustomizations> implement
         this.triggerScroll();
     }
 
-    override async sendMessageText(messageText: string) {
+    override async sendMessageText(messageText: string, options?: { timeoutMs?: number }) {
         await this.restartTimers();
         if (messageText.trim() === '') {
             return;
         }
         const messageModel = this.addMessage(false, messageText);
-        await this.emitAsync(ChatUiEvent.eventMessageSend, messageModel, this.filterStore.export());
+        await this.emitAsync(
+            ChatUiEvent.eventMessageSend,
+            messageModel,
+            this.filterStore.export(),
+            ...(options?.timeoutMs !== undefined ? [options.timeoutMs] : [])
+        );
     }
 
     @action