@iblai/web-utils 1.8.0 → 1.8.1

package/dist/index.js

@@ -802,6 +802,15 @@ const TOOLS = {
     GOOGLE_SLIDES: "google-slides",
     GOOGLE_DOCUMENT: "google-docs",
 };
+// Maps WebSocket tool_call type names to human-readable UI labels
+const TOOL_NAME_MAP = {
+    web_search_call: "Searching the web",
+    vector_search: "Searching knowledge base",
+    calculator: "Calculating",
+    file_reader: "Reading file",
+    code_executor: "Running code",
+    wikipedia: "Searching Wikipedia",
+};
 const REQUIRED_ACTIONS_FOR_GROUPS = {
     NOTIFICATIONS: "Ibl.Notifications/Notification/action",
 };
@@ -10755,41 +10764,41 @@ async function initServiceWorker(basePath = "") {
     return getServiceWorkerStatus();
 }
 
-const CHECK_NETWORK_STATUS_COMMAND = 'check_network_status';
+const CHECK_NETWORK_STATUS_COMMAND = "check_network_status";
 // CRITICAL: Eagerly import Tauri API to bundle it inline instead of lazy-loading
 // webpackMode: "eager" prevents creating a separate chunk (7427.js)
 // This ensures the code is in the main bundle and always available offline
 let tauriInvoke = null;
-if (typeof window !== 'undefined' && isTauri()) {
+if (typeof window !== "undefined" && isTauri()) {
     import(/* webpackMode: "eager" */ '@tauri-apps/api/core')
         .then((tauriCore) => {
         tauriInvoke = tauriCore.invoke;
-        console.log('[ServiceWorkerProvider] Tauri API loaded eagerly (bundled inline)');
+        console.log("[ServiceWorkerProvider] Tauri API loaded eagerly (bundled inline)");
     })
         .catch((e) => {
-        console.warn('[ServiceWorkerProvider] Failed to load Tauri API:', e);
+        console.warn("[ServiceWorkerProvider] Failed to load Tauri API:", e);
     });
 }
 // localStorage key set by the Tauri offline shell
-const TAURI_OFFLINE_MODE_KEY = 'tauri_offline_mode';
+const TAURI_OFFLINE_MODE_KEY = "tauri_offline_mode";
 /**
  * Check if the shell has marked us as offline
  */
 function isShellOfflineMode() {
-    if (typeof window === 'undefined' ||
-        typeof (localStorage === null || localStorage === void 0 ? void 0 : localStorage.getItem) !== 'function')
+    if (typeof window === "undefined" ||
+        typeof (localStorage === null || localStorage === void 0 ? void 0 : localStorage.getItem) !== "function")
         return false;
-    return localStorage.getItem(TAURI_OFFLINE_MODE_KEY) === 'true';
+    return localStorage.getItem(TAURI_OFFLINE_MODE_KEY) === "true";
 }
 const ServiceWorkerContext = React.createContext(null);
 function useServiceWorker() {
     const context = React.useContext(ServiceWorkerContext);
     if (!context) {
-        throw new Error('useServiceWorker must be used within ServiceWorkerProvider');
+        throw new Error("useServiceWorker must be used within ServiceWorkerProvider");
     }
     return context;
 }
-function ServiceWorkerProvider({ children, basePath = '', }) {
+function ServiceWorkerProvider({ children, basePath = "", }) {
     // Get initial status, considering the shell's offline flag
     const [status, setStatus] = React.useState(() => {
         const baseStatus = getServiceWorkerStatus();
@@ -10806,7 +10815,7 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
         // Skip service worker registration in Tauri offline mode
         // The offline server handles all requests, SW is not needed and will fail to register
         if (isTauriApp && shellOffline) {
-            console.log('[ServiceWorkerProvider] Skipping SW registration - Tauri offline mode');
+            console.log("[ServiceWorkerProvider] Skipping SW registration - Tauri offline mode");
             setStatus({
                 isSupported: false,
                 isRegistered: false,
@@ -10837,11 +10846,11 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
         });
         // Subscribe to updates
         const unsubscribeUpdate = onUpdate(() => {
-            sonner.toast.info('App update available', {
-                description: 'A new version is ready. Click to update.',
+            sonner.toast.info("App update available", {
+                description: "A new version is ready. Click to update.",
                 duration: 10000,
                 action: {
-                    label: 'Update',
+                    label: "Update",
                     onClick: () => {
                         skipWaiting();
                     },
@@ -10868,7 +10877,7 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
                     const isOnline = (await tauriInvoke(CHECK_NETWORK_STATUS_COMMAND));
                     setStatus((prev) => {
                         if (prev.isOnline !== isOnline) {
-                            console.log('[ServiceWorkerProvider] Network status changed:', isOnline ? 'online' : 'offline');
+                            console.log("[ServiceWorkerProvider] Network status changed:", isOnline ? "online" : "offline");
                             // Notify service worker of the change
                             setOfflineStatus(!isOnline);
                             return { ...prev, isOnline };
@@ -10881,10 +10890,10 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
                     // If we're offline and the Tauri chunk can't load, just skip network checks
                     // The error object has a 'name' property for ChunkLoadError
                     if (error &&
-                        typeof error === 'object' &&
-                        'name' in error &&
-                        error.name === 'ChunkLoadError') {
-                        console.warn('[ServiceWorkerProvider] Tauri API chunk not available (offline), disabling network checks');
+                        typeof error === "object" &&
+                        "name" in error &&
+                        error.name === "ChunkLoadError") {
+                        console.warn("[ServiceWorkerProvider] Tauri API chunk not available (offline), disabling network checks");
                         // Clear the interval to stop trying
                         if (networkCheckInterval) {
                             clearInterval(networkCheckInterval);
@@ -10892,7 +10901,7 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
                         }
                     }
                     else {
-                        console.error('[ServiceWorkerProvider] Failed to check network status:', error);
+                        console.error("[ServiceWorkerProvider] Failed to check network status:", error);
                     }
                 }
             };
@@ -10902,7 +10911,7 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
             networkCheckInterval = setInterval(checkNetworkStatus, 3000);
             // Also listen to browser offline/online events for immediate feedback
             offlineHandler = () => {
-                console.log('[ServiceWorkerProvider] Browser offline event fired');
+                console.log("[ServiceWorkerProvider] Browser offline event fired");
                 setStatus((prev) => {
                     if (prev.isOnline) {
                         setOfflineStatus(true);
@@ -10914,12 +10923,12 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
                 setTimeout(checkNetworkStatus, 500);
             };
             onlineHandler = () => {
-                console.log('[ServiceWorkerProvider] Browser online event fired');
+                console.log("[ServiceWorkerProvider] Browser online event fired");
                 // Verify with Tauri before marking as online
                 checkNetworkStatus();
             };
-            window.addEventListener('offline', offlineHandler);
-            window.addEventListener('online', onlineHandler);
+            window.addEventListener("offline", offlineHandler);
+            window.addEventListener("online", onlineHandler);
         }
         return () => {
             unsubscribeUpdate();
@@ -10928,10 +10937,10 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
                 clearInterval(networkCheckInterval);
             }
             if (offlineHandler) {
-                window.removeEventListener('offline', offlineHandler);
+                window.removeEventListener("offline", offlineHandler);
             }
             if (onlineHandler) {
-                window.removeEventListener('online', onlineHandler);
+                window.removeEventListener("online", onlineHandler);
             }
         };
     }, [basePath]);
@@ -10940,8 +10949,8 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
     }, []);
     const clearCache = React.useCallback(() => {
         clearAllCaches();
-        sonner.toast.success('Cache cleared', {
-            description: 'All cached data has been cleared.',
+        sonner.toast.success("Cache cleared", {
+            description: "All cached data has been cleared.",
         });
     }, []);
     const refreshCacheStatus = React.useCallback(async () => {
@@ -10973,13 +10982,13 @@ function ServiceWorkerProvider({ children, basePath = '', }) {
         catch (error) {
             // CRITICAL: Catch chunk load errors and fall back to navigator.onLine
             if (error &&
-                typeof error === 'object' &&
-                'name' in error &&
-                error.name === 'ChunkLoadError') {
-                console.warn('[ServiceWorkerProvider] Tauri API chunk not available, using navigator.onLine');
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "ChunkLoadError") {
+                console.warn("[ServiceWorkerProvider] Tauri API chunk not available, using navigator.onLine");
                 return navigator.onLine;
             }
-            console.error('[ServiceWorkerProvider] Failed to check network status:', error);
+            console.error("[ServiceWorkerProvider] Failed to check network status:", error);
             return navigator.onLine; // Fallback to browser API
         }
     }, []);
@@ -11006,6 +11015,9 @@ const initialState$5 = {
     currentStreamingMessage: {
         id: "",
         content: "",
+        reasoningContent: "",
+        toolCalls: [],
+        isReasoning: false,
     },
     currentStreamingArtifact: null,
     activeTab: "chat",
@@ -11029,6 +11041,9 @@ const initialState$5 = {
     // Buffering state initialized
     streamingArtifactContentBuffer: "",
     lastArtifactContentFlushTime: 0,
+    // Reasoning buffering state initialized
+    streamingReasoningContentBuffer: "",
+    lastReasoningContentFlushTime: 0,
     metadata: {
         edxCourseId: "",
         edxUsageId: "",
@@ -11058,6 +11073,8 @@ const chatSlice = createSlice({
                     content: state.currentStreamingMessage.content,
                     timestamp: new Date().toISOString(),
                     visible: true,
+                    reasoningContent: state.currentStreamingMessage.reasoningContent,
+                    toolCalls: state.currentStreamingMessage.toolCalls,
                 };
                 state.chats = {
                     ...state.chats,
@@ -11068,6 +11085,8 @@ const chatSlice = createSlice({
                 const temp = {
                     ...lastMessageInActiveTabMessages,
                     content: state.currentStreamingMessage.content,
+                    reasoningContent: state.currentStreamingMessage.reasoningContent,
+                    toolCalls: state.currentStreamingMessage.toolCalls,
                 };
                 state.chats = {
                     ...state.chats,
@@ -11106,8 +11125,58 @@ const chatSlice = createSlice({
         setCurrentStreamingMessage: (state, action) => {
             state.currentStreamingMessage = action.payload;
         },
+        // Partial update that only sets id/content without resetting reasoning/tool data
+        setStreamingMessageIdAndContent: (state, action) => {
+            state.currentStreamingMessage.id = action.payload.id;
+            state.currentStreamingMessage.content = action.payload.content;
+        },
         resetCurrentStreamingMessage: (state) => {
-            state.currentStreamingMessage = { id: "", content: "" };
+            state.currentStreamingMessage = {
+                id: "",
+                content: "",
+                reasoningContent: "",
+                toolCalls: [],
+                isReasoning: false,
+            };
+            // Reset reasoning buffer as well
+            state.streamingReasoningContentBuffer = "";
+            state.lastReasoningContentFlushTime = 0;
+        },
+        // Buffer reasoning tokens, flush at threshold
+        appendReasoningContent: (state, action) => {
+            // Add to buffer
+            state.streamingReasoningContentBuffer += action.payload;
+            // Check if we should flush (threshold reached)
+            const shouldFlush = state.streamingReasoningContentBuffer.length >=
+                STREAMING_CONTENT_BUFFER_THRESHOLD;
+            if (shouldFlush) {
+                // Flush buffer to actual content
+                state.currentStreamingMessage.reasoningContent +=
+                    state.streamingReasoningContentBuffer;
+                state.streamingReasoningContentBuffer = "";
+                state.lastReasoningContentFlushTime = Date.now();
+            }
+        },
+        // Force-flush buffered reasoning to currentStreamingMessage
+        flushReasoningBuffer: (state, _action) => {
+            if (state.streamingReasoningContentBuffer.length > 0) {
+                state.currentStreamingMessage.reasoningContent +=
+                    state.streamingReasoningContentBuffer;
+                state.streamingReasoningContentBuffer = "";
+                state.lastReasoningContentFlushTime = Date.now();
+            }
+        },
+        // Set isReasoning flag without touching other fields
+        setIsReasoning: (state, action) => {
+            state.currentStreamingMessage.isReasoning = action.payload;
+        },
+        // Sets isReasoning = false (triggers UI collapse)
+        setReasoningComplete: (state, _action) => {
+            state.currentStreamingMessage.isReasoning = false;
+        },
+        // Appends tool call entry
+        addToolCall: (state, action) => {
+            state.currentStreamingMessage.toolCalls.push(action.payload);
         },
         updateStreamingMessageId: (state, action) => {
             const oldId = state.currentStreamingMessage.id;
@@ -11265,11 +11334,15 @@ const chatSlice = createSlice({
             }
             const activeMessages = state.chats[state.activeTab];
             const lastMessage = activeMessages[activeMessages.length - 1];
+            const toolCalls = state.currentStreamingMessage.toolCalls || [];
+            const reasoningContent = state.currentStreamingMessage.reasoningContent || "";
             if (!lastMessage || lastMessage.id !== streamingId) {
                 const temp = {
                     id: streamingId,
                     role: "assistant",
                     content: state.currentStreamingMessage.content,
+                    reasoningContent,
+                    toolCalls,
                     timestamp: new Date().toISOString(),
                     visible: true,
                 };
@@ -11278,6 +11351,19 @@ const chatSlice = createSlice({
                     [state.activeTab]: [...activeMessages, temp],
                 };
             }
+            else {
+                const updatedMessages = [...activeMessages];
+                updatedMessages[activeMessages.length - 1] = {
+                    ...lastMessage,
+                    content: state.currentStreamingMessage.content,
+                    reasoningContent,
+                    toolCalls,
+                };
+                state.chats = {
+                    ...state.chats,
+                    [state.activeTab]: updatedMessages,
+                };
+            }
         },
         upsertStreamingArtifactVersionOnLastMessage: (state, action) => {
             const { artifactId, title, content, fileExtension, sessionId, versionNumber = 1, username, metadata, isPartial, } = action.payload;
@@ -11480,6 +11566,16 @@ const selectStreamingArtifactFullContent = (state) => {
         return null;
     return artifact.content + buffer;
 };
+// NEW: Get the full streaming reasoning content including buffer
+const selectStreamingReasoningContent = (state) => {
+    const reasoningContent = state.chatSliceShared.currentStreamingMessage.reasoningContent;
+    const buffer = state.chatSliceShared.streamingReasoningContentBuffer;
+    return reasoningContent + buffer;
+};
+// NEW: Get isReasoning flag
+const selectIsReasoning = (state) => state.chatSliceShared.currentStreamingMessage.isReasoning;
+// NEW: Get streaming tool calls
+const selectStreamingToolCalls = (state) => state.chatSliceShared.currentStreamingMessage.toolCalls;
 
 class TimeTracker {
     constructor(config) {
@@ -12265,6 +12361,8 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
     const currentStreamingMessage = React.useRef({
         id: null,
         content: "",
+        reasoningContent: "",
+        toolCalls: [],
     });
     // Track artifact state during streaming
     const currentArtifact = React.useRef(null);
@@ -12278,6 +12376,14 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
         lastFlushTime: 0,
         flushTimer: null,
     });
+    // NEW: Content buffer for batching reasoning streaming updates
+    const reasoningContentBuffer = React.useRef({
+        content: "",
+        lastFlushTime: 0,
+        flushTimer: null,
+    });
+    // NEW: Track if we've seen reasoning tokens to detect transition to response
+    const hasSeenReasoning = React.useRef(false);
     const stopGenerationSocket = React.useRef(null);
     const isInitialConnection = React.useRef(true);
     const connectionAttempts = React.useRef(0);
@@ -12958,6 +13064,22 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
                         }
                         return;
                     }
+                    // NEW: Handle top-level tool_call messages (separate message type)
+                    if (messageData.type === "tool_call" && messageData.value) {
+                        const toolCallValue = messageData.value;
+                        // Dispatch tool call to Redux
+                        dispatch(chatActions.addToolCall({
+                            id: toolCallValue.id || "",
+                            name: toolCallValue.name || "",
+                            input: toolCallValue.tool_input,
+                            log: toolCallValue.log || "",
+                            result: toolCallValue.result || "",
+                        }));
+                        // Ensure message exists in array and update it with latest data
+                        dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                        // Early return since tool_call messages don't have data/eos fields
+                        return;
+                    }
                     // Handle start of new streaming session
                     if (messageData.generation_id &&
                         !messageData.data &&
@@ -12970,6 +13092,21 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
                             id: messageData.generation_id,
                             content: "",
                         };
+                        // Reset Redux streaming message with all fields
+                        dispatch(chatActions.setCurrentStreamingMessage({
+                            id: messageData.generation_id,
+                            content: "",
+                            reasoningContent: "",
+                            toolCalls: [],
+                            isReasoning: false,
+                        }));
+                        // NEW: Reset reasoning refs and buffer for new generation
+                        hasSeenReasoning.current = false;
+                        reasoningContentBuffer.current = {
+                            content: "",
+                            lastFlushTime: 0,
+                            flushTimer: null,
+                        };
                         onStreamingMessageUpdate === null || onStreamingMessageUpdate === void 0 ? void 0 : onStreamingMessageUpdate(currentStreamingMessage.current);
                         onStatusChange("streaming");
                         onStreamingChange(true);
@@ -12992,7 +13129,69 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
                     // Handle streaming message content (chat text)
                     if ((messageData === null || messageData === void 0 ? void 0 : messageData.type) !== "chat_messages" &&
                         (messageData.data !== undefined || messageData.eos !== undefined)) {
+                        // NEW: Handle annotations (reasoning tokens) BEFORE processing data
+                        if (messageData.annotations &&
+                            Array.isArray(messageData.annotations)) {
+                            for (const annotation of messageData.annotations) {
+                                if (annotation.type === "reasoning" && annotation.text) {
+                                    // Mark that we've seen reasoning
+                                    hasSeenReasoning.current = true;
+                                    // Set isReasoning to true without overwriting toolCalls
+                                    dispatch(chatActions.setIsReasoning(true));
+                                    // Ensure message exists in array immediately so reasoning section appears
+                                    dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                                    // Buffer reasoning content
+                                    reasoningContentBuffer.current.content += annotation.text;
+                                    // Check if we should flush (threshold or timer)
+                                    const shouldFlush = reasoningContentBuffer.current.content.length >=
+                                        STREAMING_CONTENT_BUFFER_THRESHOLD;
+                                    const now = Date.now();
+                                    const timeSinceLastFlush = now - reasoningContentBuffer.current.lastFlushTime;
+                                    if (shouldFlush ||
+                                        timeSinceLastFlush >= STREAMING_CONTENT_FLUSH_INTERVAL) {
+                                        // Flush buffer to Redux
+                                        dispatch(chatActions.appendReasoningContent(reasoningContentBuffer.current.content));
+                                        reasoningContentBuffer.current.content = "";
+                                        reasoningContentBuffer.current.lastFlushTime = now;
+                                        // Ensure message exists in array and update it with latest data
+                                        dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                                    }
+                                    else {
+                                        // Set up timer to flush if not already set
+                                        if (!reasoningContentBuffer.current.flushTimer) {
+                                            reasoningContentBuffer.current.flushTimer = setTimeout(() => {
+                                                if (reasoningContentBuffer.current.content.length > 0) {
+                                                    dispatch(chatActions.appendReasoningContent(reasoningContentBuffer.current.content));
+                                                    reasoningContentBuffer.current.content = "";
+                                                    reasoningContentBuffer.current.lastFlushTime =
+                                                        Date.now();
+                                                    // Ensure message exists in array and update it with latest data
+                                                    dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                                                }
+                                                reasoningContentBuffer.current.flushTimer = null;
+                                            }, STREAMING_CONTENT_FLUSH_INTERVAL);
+                                        }
+                                    }
+                                }
+                            }
+                        }
                         const messageText = messageData.data || "";
+                        // NEW: Detect reasoning→response transition (first non-empty data after reasoning)
+                        if (messageText && hasSeenReasoning.current) {
+                            // Flush remaining reasoning buffer
+                            if (reasoningContentBuffer.current.content.length > 0) {
+                                dispatch(chatActions.appendReasoningContent(reasoningContentBuffer.current.content));
+                                reasoningContentBuffer.current.content = "";
+                            }
+                            // Flush reasoning buffer in Redux
+                            dispatch(chatActions.flushReasoningBuffer(undefined));
+                            // Mark reasoning as complete
+                            dispatch(chatActions.setReasoningComplete(undefined));
+                            // Update message in array with final reasoning state
+                            dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                            // Reset flag so we only do this once
+                            hasSeenReasoning.current = false;
+                        }
                         // If we have content to add, update the in-memory streaming message and Redux
                         if (messageText && currentStreamingMessage.current) {
                             console.log("[ws-message] Streaming content chunk:", {
@@ -13006,13 +13205,28 @@ const useChat = ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, e
                                 content: currentStreamingMessage.current.content + messageText,
                             };
                             onStreamingMessageUpdate === null || onStreamingMessageUpdate === void 0 ? void 0 : onStreamingMessageUpdate(currentStreamingMessage.current);
-                            // Update or add message in Redux store
+                            // Update or add message in Redux store - use ensureStreamingAssistantMessage for consistency
                             if ((_w = currentStreamingMessage.current) === null || _w === void 0 ? void 0 : _w.id) {
-                                // TODO: Investigate why `appendMessageToActiveTab` is consuming this action payload
-                                dispatch(chatActions.appendMessageToActiveTab(undefined));
+                                dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
                             }
                         }
                         if (messageData.eos) {
+                            // NEW: Flush any remaining reasoning buffer on EOS
+                            if (reasoningContentBuffer.current.content.length > 0) {
+                                dispatch(chatActions.appendReasoningContent(reasoningContentBuffer.current.content));
+                                reasoningContentBuffer.current.content = "";
+                            }
+                            // Flush reasoning buffer in Redux
+                            dispatch(chatActions.flushReasoningBuffer(undefined));
+                            // Mark reasoning as complete
+                            dispatch(chatActions.setReasoningComplete(undefined));
+                            // Update message in array with final state
+                            dispatch(chatActions.ensureStreamingAssistantMessage(undefined));
+                            // Clear any pending flush timer
+                            if (reasoningContentBuffer.current.flushTimer) {
+                                clearTimeout(reasoningContentBuffer.current.flushTimer);
+                                reasoningContentBuffer.current.flushTimer = null;
+                            }
                             // Handle end of stream
                             const hasPendingArtifact = !!pendingArtifactVersion.current;
                             const hasMessageContent = !!((_x = currentStreamingMessage.current) === null || _x === void 0 ? void 0 : _x.content) &&
@@ -13627,7 +13841,13 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
         dispatch(chatActions.setStatus(status));
     };
     const onStreamingMessageUpdate = (message) => {
-        dispatch(chatActions.setCurrentStreamingMessage(message));
+        // Use setStreamingMessageIdAndContent to avoid resetting reasoning/tool state
+        if (message.id) {
+            dispatch(chatActions.setStreamingMessageIdAndContent({
+                id: message.id,
+                content: message.content,
+            }));
+        }
     };
     const { sendMessage, stopGenerating, ws, isConnected, messageQueue, resetConnection, } = useChat({
         wsUrl,
@@ -13709,7 +13929,7 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
             try {
                 previousChats =
                     ((_d = (_c = data === null || data === void 0 ? void 0 : data.data) === null || _c === void 0 ? void 0 : _c.results) === null || _d === void 0 ? void 0 : _d.map((result) => {
-                        var _a, _b, _c;
+                        var _a, _b, _c, _d, _e, _f;
                         const artifactVersions = (_a = result.artifact_versions) === null || _a === void 0 ? void 0 : _a.map((av) => {
                             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
                             return ({
@@ -13748,6 +13968,30 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
                             fileSize: file.file_size,
                             uploadUrl: file.url,
                         }))) || [];
+                        // Extract additional_kwargs - check both direct and nested paths
+                        const additionalKwargs = result.additional_kwargs ||
+                            ((_d = (_c = result.message) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.additional_kwargs);
+                        // Extract reasoning content from additional_kwargs
+                        const reasoningSummaries = (_e = additionalKwargs === null || additionalKwargs === void 0 ? void 0 : additionalKwargs.reasoning) === null || _e === void 0 ? void 0 : _e.summary;
+                        const reasoningContent = Array.isArray(reasoningSummaries)
+                            ? reasoningSummaries
+                                .map((s) => s.text)
+                                .filter(Boolean)
+                                .join("\n\n")
+                            : undefined;
+                        // Extract tool calls from additional_kwargs
+                        const toolOutputs = additionalKwargs === null || additionalKwargs === void 0 ? void 0 : additionalKwargs.tool_outputs;
+                        const toolCalls = Array.isArray(toolOutputs)
+                            ? toolOutputs.map((tool) => {
+                                var _a;
+                                return ({
+                                    id: tool.id || "",
+                                    name: tool.type || "",
+                                    log: ((_a = tool.action) === null || _a === void 0 ? void 0 : _a.query) || "",
+                                    result: tool.status || "",
+                                });
+                            })
+                            : undefined;
                         return {
                             ...result,
                             role: result.type === "human" ? "user" : "assistant",
@@ -13755,17 +13999,45 @@ function useAdvancedChat({ tenantKey, mentorId, username = ANONYMOUS_USERNAME, t
                             id: result.id || new Date().getTime(),
                             content: typeof result.content === "object" &&
                                 result.content.length > 0
-                                ? (_c = result.content.find((item) => item.text)) === null || _c === void 0 ? void 0 : _c.text
+                                ? (_f = result.content.find((item) => item.text)) === null || _f === void 0 ? void 0 : _f.text
                                 : result.content,
                             // Add transformed artifact versions
                             artifactVersions: artifactVersions || undefined,
                             fileAttachments: fileAttachments.length > 0 ? fileAttachments : undefined,
+                            reasoningContent: reasoningContent || undefined,
+                            toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
                         };
                     }).reverse()) || [];
             }
             catch (error) {
                 console.error(JSON.stringify(error));
             }
+            // Preserve reasoningContent and toolCalls from existing messages
+            // when the session API re-fetch doesn't include additional_kwargs.
+            const existingMessages = chats[activeTab] || [];
+            if (existingMessages.length > 0 && previousChats.length > 0) {
+                const existingByContent = new Map();
+                for (const m of existingMessages) {
+                    if (m.reasoningContent || (m.toolCalls && m.toolCalls.length > 0)) {
+                        existingByContent.set(m.content, m);
+                    }
+                }
+                if (existingByContent.size > 0) {
+                    for (const msg of previousChats) {
+                        const existing = existingByContent.get(msg.content);
+                        if (existing) {
+                            if (!msg.reasoningContent && existing.reasoningContent) {
+                                msg.reasoningContent = existing.reasoningContent;
+                            }
+                            if ((!msg.toolCalls || msg.toolCalls.length === 0) &&
+                                existing.toolCalls &&
+                                existing.toolCalls.length > 0) {
+                                msg.toolCalls = existing.toolCalls;
+                            }
+                        }
+                    }
+                }
+            }
             dispatch(chatActions.setNewMessages(previousChats));
         }
         catch (error) {
@@ -17943,6 +18215,7 @@ exports.ServiceWorkerProvider = ServiceWorkerProvider;
 exports.SubscriptionFlow = SubscriptionFlow;
 exports.SubscriptionFlowV2 = SubscriptionFlowV2;
 exports.TOOLS = TOOLS;
+exports.TOOL_NAME_MAP = TOOL_NAME_MAP;
 exports.TenantContext = TenantContext;
 exports.TenantContextProvider = TenantContextProvider;
 exports.TenantProvider = TenantProvider;
@@ -18047,6 +18320,7 @@ exports.selectEnableChatActionsPopup = selectEnableChatActionsPopup;
 exports.selectIframeContext = selectIframeContext;
 exports.selectIsError = selectIsError;
 exports.selectIsPending = selectIsPending;
+exports.selectIsReasoning = selectIsReasoning;
 exports.selectIsStopped = selectIsStopped;
 exports.selectIsTyping = selectIsTyping;
 exports.selectLastArtifactContentFlushTime = selectLastArtifactContentFlushTime;
@@ -18061,6 +18335,8 @@ exports.selectStatus = selectStatus;
 exports.selectStreaming = selectStreaming;
 exports.selectStreamingArtifactContentBuffer = selectStreamingArtifactContentBuffer;
 exports.selectStreamingArtifactFullContent = selectStreamingArtifactFullContent;
+exports.selectStreamingReasoningContent = selectStreamingReasoningContent;
+exports.selectStreamingToolCalls = selectStreamingToolCalls;
 exports.selectToken = selectToken;
 exports.selectTokenEnabled = selectTokenEnabled;
 exports.selectTools = selectTools;