@iblai/web-utils 1.6.9 → 1.6.10

package/dist/index.js

@@ -11040,8 +11040,16 @@ const chatSlice = createSlice({
             state.chats = action.payload;
         },
         appendMessageToActiveTab: (state) => {
-            const lastMessageInActiveTabMessages = state.chats[state.activeTab][state.chats[state.activeTab].length - 1];
-            if (lastMessageInActiveTabMessages.id !== state.currentStreamingMessage.id) {
+            const activeMessages = state.chats[state.activeTab];
+            // Defensive: if the active tab has no messages yet (e.g. a stale
+            // `setNewMessages([])` raced ahead of the user-message dispatch),
+            // skip the lookup that would throw on `undefined.id` and rely on
+            // the no-last-message branch below to append the streaming message.
+            const lastMessageInActiveTabMessages = activeMessages && activeMessages.length > 0
+                ? activeMessages[activeMessages.length - 1]
+                : undefined;
+            if (!lastMessageInActiveTabMessages ||
+                lastMessageInActiveTabMessages.id !== state.currentStreamingMessage.id) {
                 const temp = {
                     id: state.currentStreamingMessage.id,
                     role: "assistant",
@@ -13550,7 +13558,7 @@ function useMentorSettings({ mentorId, tenantKey, isPublicRoute = false, mainTen
     };
 }
 
-function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, token, wsUrl, stopGenerationWsUrl, redirectToAuthSpa, errorHandler, sendMessageToParentWebsite, isPreviewMode, mentorShareableToken, on402Error, cachedSessionId, onStartNewChat, onOAuthRequired, onOAuthResolved, isOffline = false, onOfflineWithoutLocalLLM, isPublicRoute, }) {
+function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, token, wsUrl, stopGenerationWsUrl, redirectToAuthSpa, errorHandler, sendMessageToParentWebsite, isPreviewMode, mentorShareableToken, on402Error, cachedSessionId, onStartNewChat, onOAuthRequired, onOAuthResolved, isOffline = false, onOfflineWithoutLocalLLM, isPublicRoute, initialPrompt, }) {
     var _a, _b, _c, _d;
     const dispatch = useDispatch();
     const [createSessionId, { isLoading: isLoadingSessionIds }] = dataLayer.useCreateSessionIdMutation();
@@ -13605,10 +13613,41 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
         onOfflineWithoutLocalLLM,
     });
     const [isLoadingChats, setIsLoadingChats] = React.useState(true);
+    // Tracks whether the optional `initialPrompt` prop has already been
+    // auto-submitted for this hook instance. Set to `true` the moment the
+    // effect decides to act (either to send or because the prompt is already
+    // the most recent user message) so subsequent re-renders never re-fire.
+    const initialPromptInjectedRef = React.useRef(false);
+    // Tracks whether a `startNewChat()` call is already mid-flight. The
+    // auto-start `useEffect` below re-runs whenever any of its deps change
+    // (`shouldStartNewChat` in particular toggles after mount in many
+    // consumers), and the existing `!cachedSessionId?.[mentorId]` guard is
+    // not enough on its own because `cachedSessionId` only updates AFTER
+    // `createSessionId` resolves. Without this ref, dep churn during the
+    // pending API call triggers a second `startNewChat`, producing two
+    // sessions, two `getChats` calls, and an extra `setNewMessages([])`
+    // that wipes anything dispatched (like `initialPrompt`'s
+    // `addUserMessage`) between the two `getChats` resolutions.
+    const startNewChatInFlightRef = React.useRef(false);
+    // Synchronous mirror of `isLoadingChats`. The state setter is async, so a
+    // consumer effect running in the SAME render cycle as `getChats()`
+    // invocation sees a stale `isLoadingChats=false` in its closure even
+    // though `setIsLoadingChats(true)` has been scheduled. The ref flips
+    // immediately (before `getChats` hits its first `await`), giving the
+    // `initialPrompt` injection effect a reliable "fetch in progress" signal
+    // it can read synchronously inside its body.
+    const isLoadingChatsRef = React.useRef(true);
     const [getSessionChats] = dataLayer.useLazyGetSessionIdQuery();
     const [getSharedSessionChats] = dataLayer.useLazyGetSharedSessionIdQuery();
     const getChats = React.useCallback(async () => {
         var _a, _b, _c, _d;
+        // Mark the fetch as in-flight so consumers gated on `isLoadingChats`
+        // (e.g. the `initialPrompt` injection effect) defer until the resulting
+        // `setNewMessages` has landed. The state setter alone is not enough —
+        // it's async and the consumer effect may run in the same render cycle
+        // with the stale closure — so flip the synchronous ref FIRST.
+        isLoadingChatsRef.current = true;
+        setIsLoadingChats(true);
         let data;
         try {
             if (showingSharedChat) {
@@ -13693,6 +13732,7 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
         }
         finally {
             setIsLoadingChats(false);
+            isLoadingChatsRef.current = false;
         }
     }, [
         showingSharedChat,
@@ -13704,21 +13744,30 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
         getSessionChats,
         dispatch,
     ]);
+    // Depend on the indexed string session id, not the whole `cachedSessionId`
+    // object. Consumers (e.g. `useLocalStorage`) often re-emit a new object
+    // reference on every render even when the underlying value is unchanged,
+    // which would otherwise cause this effect to re-fire `getChats()` per
+    // render — and each `setNewMessages` would wipe any user message
+    // dispatched in between (the URL `initialPrompt` race).
+    const currentMentorSessionId = cachedSessionId === null || cachedSessionId === void 0 ? void 0 : cachedSessionId[mentorId];
     React.useEffect(() => {
-        if (cachedSessionId === null || cachedSessionId === void 0 ? void 0 : cachedSessionId[mentorId]) {
-            dispatch(chatActions.updateSessionIds(cachedSessionId === null || cachedSessionId === void 0 ? void 0 : cachedSessionId[mentorId]));
+        if (currentMentorSessionId) {
+            dispatch(chatActions.updateSessionIds(currentMentorSessionId));
             // Skip fetching previous chats when offline
             if (!isOffline) {
                 getChats();
             }
             else {
                 setIsLoadingChats(false);
+                isLoadingChatsRef.current = false;
             }
         }
         else {
             setIsLoadingChats(false);
+            isLoadingChatsRef.current = false;
         }
-    }, [cachedSessionId, isOffline]);
+    }, [currentMentorSessionId, isOffline]);
     const startNewChat = React.useCallback(async () => {
         // Reset all chat state
         if (!showingSharedChat) {
@@ -13781,10 +13830,15 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
         errorHandler,
     ]);
     React.useEffect(() => {
+        if (startNewChatInFlightRef.current)
+            return;
         if (!showingSharedChat || mentorSettings.allowAnonymous) {
             if (mentorSettings.allowAnonymous !== undefined &&
                 !(cachedSessionId === null || cachedSessionId === void 0 ? void 0 : cachedSessionId[mentorId])) {
-                startNewChat();
+                startNewChatInFlightRef.current = true;
+                startNewChat().finally(() => {
+                    startNewChatInFlightRef.current = false;
+                });
             }
         }
     }, [shouldStartNewChat, showingSharedChat, mentorSettings.allowAnonymous]);
@@ -13795,6 +13849,76 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
             resetConnection();
         }
     }, [sessionIds, activeTab, sessionId, resetConnection]);
+    // Auto-submit `initialPrompt` exactly once per mount after the chat
+    // lifecycle has stabilized. Matches the existing proactive-prompt
+    // precedent in `changeTab` (sendMessage(tab, content)) but is gated on
+    // URL-driven deep-link signals instead of tab transitions.
+    React.useEffect(() => {
+        var _a;
+        if (initialPromptInjectedRef.current)
+            return;
+        const trimmedPrompt = initialPrompt === null || initialPrompt === void 0 ? void 0 : initialPrompt.trim();
+        if (!trimmedPrompt)
+            return;
+        // Bail while any state would make auto-submission unsafe or premature.
+        if (isPreviewMode)
+            return;
+        if (showingSharedChat)
+            return;
+        if (isOffline)
+            return;
+        // Two-layer guard: the state catches re-runs after `getChats` settles
+        // (which schedule a new render). The ref catches the in-render race
+        // where this effect runs in the same cycle that `getChats` was invoked
+        // — the state setter is async and the closure has a stale `false`.
+        if (isLoadingChats)
+            return;
+        if (isLoadingChatsRef.current)
+            return;
+        if (!sessionIds[activeTab])
+            return;
+        if (streaming)
+            return;
+        if (isPending)
+            return;
+        // Dedup: scan back through the loaded history for the most recent
+        // user message and compare its content. If it matches, this session
+        // already has the prompt as a user turn (typical case: reload of a
+        // `?prompt=` URL — the cached history ends with the assistant reply,
+        // so the matching user message is one step back).
+        const messages = chats[activeTab];
+        let lastUserMessage;
+        if (messages && messages.length > 0) {
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (((_a = messages[i]) === null || _a === void 0 ? void 0 : _a.role) === "user") {
+                    lastUserMessage = messages[i];
+                    break;
+                }
+            }
+        }
+        if (lastUserMessage &&
+            typeof lastUserMessage.content === "string" &&
+            lastUserMessage.content === trimmedPrompt) {
+            initialPromptInjectedRef.current = true;
+            return;
+        }
+        // Mark BEFORE dispatching: sendMessage triggers state updates that may
+        // re-run this effect, and we want the guard active before any re-fire.
+        initialPromptInjectedRef.current = true;
+        sendMessage(activeTab, trimmedPrompt);
+    }, [
+        initialPrompt,
+        isPreviewMode,
+        showingSharedChat,
+        isOffline,
+        isLoadingChats,
+        sessionIds,
+        activeTab,
+        chats,
+        streaming,
+        isPending,
+        sendMessage,
+    ]);
     async function changeTab(tab) {
         var _a, _b, _c, _d;
         // while responding to a message, do not change the tab