@iblai/web-utils 1.11.4 → 1.11.6

package/dist/index.js

@@ -9395,6 +9395,14 @@ async function validateJwtToken(storageService) {
         return false;
     }
 }
+/**
+ * How long (ms) a redirect may be "in progress" before we assume the
+ * navigation failed and allow a fresh attempt. Must be longer than the 3s
+ * safety timer in `safeRedirectToAuthSpa` so the two don't fight; this is
+ * the backstop for when that timer is lost because the page began
+ * unloading and then survived (bfcache restore, aborted navigation).
+ */
+const REDIRECT_STUCK_MS = 5000;
 function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure, redirectToAuthSpa, username, pathname, storageService, skipAuthCheck, token, enableStorageSync = true, }) {
     const [isAuthenticating, setIsAuthenticating] = React.useState(true);
     const [userIsAccessingPublicRoute, setUserIsAccessingPublicRoute] = React.useState(false);
@@ -9402,21 +9410,51 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
     const cookieCheckIntervalRef = React.useRef(null);
     const lastLogoutTimestampRef = React.useRef(null);
     const lastLoginTimestampRef = React.useRef(null);
-    // Guard to prevent poll from firing after a redirect has been initiated.
-    // Once set, no further redirects or cookie syncs will happen.
+    // Guard to prevent the poll from firing redundant redirects while a
+    // navigation to the auth SPA is already underway.
     const isRedirectingRef = React.useRef(false);
+    // Wall-clock time (ms) at which the in-progress redirect was started.
+    // Used to self-heal a stuck guard: the browser discards our 3s safety
+    // timer the instant navigation begins, so if navigation never actually
+    // completes (page restored from bfcache, redirect aborted/slow, timers
+    // throttled during unload) the boolean alone would latch ON forever and
+    // suppress every future redirect. This timestamp lets the poll detect
+    // that case and reset the guard. See `redirectInProgress`.
+    const redirectStartedAtRef = React.useRef(0);
     // RTK Query hook for refreshing JWT token
     const [refreshJwtToken] = dataLayer.useLazyRefreshJwtTokenQuery();
     /**
-     * Wrapper around redirectToAuthSpa that stops polling immediately
-     * and prevents any further redirect calls from racing.
+     * Whether a redirect is genuinely still in progress.
+     *
+     * Returns false (and resets the guard) when the redirect was started more
+     * than REDIRECT_STUCK_MS ago, since at that point the page is clearly
+     * still alive and the navigation must have failed. This is what lets the
+     * app recover on its own instead of latching the guard ON forever and
+     * needing a manual cookie clear / hard reload.
+     */
+    const redirectInProgress = () => {
+        if (!isRedirectingRef.current)
+            return false;
+        const elapsed = Date.now() - redirectStartedAtRef.current;
+        if (elapsed > REDIRECT_STUCK_MS) {
+            console.log("[AuthProvider] redirect guard stuck for", elapsed, "ms — navigation never completed, resetting so we can retry");
+            isRedirectingRef.current = false;
+            redirectStartedAtRef.current = 0;
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Wrapper around redirectToAuthSpa that prevents redundant redirect calls
+     * from racing while a navigation is already underway.
      */
     const safeRedirectToAuthSpa = (...args) => {
-        if (isRedirectingRef.current) {
+        if (redirectInProgress()) {
             console.log("[AuthProvider] Redirect already in progress, skipping");
             return;
         }
         isRedirectingRef.current = true;
+        redirectStartedAtRef.current = Date.now();
         // NOTE: we intentionally do NOT clear the interval here.
         // The isRedirectingRef guard prevents redundant redirects while navigation
         // is in progress. Clearing the interval preemptively can permanently stop
@@ -9431,6 +9469,7 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
             if (isRedirectingRef.current) {
                 console.log("[AuthProvider] safeRedirectToAuthSpa: navigation did not occur, resetting redirect guard");
                 isRedirectingRef.current = false;
+                redirectStartedAtRef.current = 0;
             }
         }, 3000);
     };
@@ -9457,6 +9496,7 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         }
         // Reset redirect guard on effect setup (new mount / dep change)
         isRedirectingRef.current = false;
+        redirectStartedAtRef.current = 0;
         // Initial sync on mount
         async function initialSync() {
             console.log("[AuthProvider] initialSync starting");
@@ -9487,8 +9527,11 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         initialSync();
         // Poll for cookie changes every 2 seconds to detect cross-SPA updates
         cookieCheckIntervalRef.current = setInterval(async () => {
-            // If a redirect is already in progress, skip entirely
-            if (isRedirectingRef.current) {
+            // If a redirect is genuinely still in progress, skip entirely.
+            // redirectInProgress() self-heals a guard that got stuck because a
+            // navigation was initiated but the page survived (bfcache, aborted
+            // redirect), so this no longer latches ON forever.
+            if (redirectInProgress()) {
                 console.log("[AuthProvider] interval: redirect already in progress, skipping");
                 return;
             }
@@ -9561,6 +9604,27 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         window.addEventListener("storage", handleStorageChange);
         return () => window.removeEventListener("storage", handleStorageChange);
     }, [storageService, enableStorageSync]);
+    /**
+     * Reset the redirect guard when the page is restored from the back/forward
+     * cache (web only). When a redirect calls window.location.href the browser
+     * may freeze and bfcache the page rather than destroy it; navigating back
+     * then restores it with isRedirectingRef still latched ON and the 3s safety
+     * timer discarded. Clearing the guard here lets redirects fire again
+     * without a manual cookie clear / hard reload.
+     */
+    React.useEffect(() => {
+        if (!isWeb$1() || skipAuthCheck)
+            return;
+        const handlePageShow = (event) => {
+            if (event.persisted) {
+                console.log("[AuthProvider] pageshow from bfcache — resetting redirect guard");
+                isRedirectingRef.current = false;
+                redirectStartedAtRef.current = 0;
+            }
+        };
+        window.addEventListener("pageshow", handlePageShow);
+        return () => window.removeEventListener("pageshow", handlePageShow);
+    }, [skipAuthCheck]);
     /**
      * Performs the authentication check by:
      * 1. Validating the auth token
@@ -12365,7 +12429,35 @@ const selectEnableChatActionsPopup = (state) => state.chat.enableChatActionsPopu
  * because browsers block mixed content (HTTPS page -> HTTP localhost).
  */
 const OLLAMA_BASE_URL = "http://localhost:11434";
+/**
+ * Ollama-compatible MCP/tool proxy. Chat for tool-capable models is routed here
+ * (instead of plain Ollama) so the model gets MCP tools. The host (ghost-os)
+ * owns the real routing for the Tauri path; this is the fetch-path equivalent.
+ */
+const TOOL_BRIDGE_BASE_URL = "http://localhost:8000";
 const OLLAMA_MODEL = "phi3:mini";
+const LOCAL_LLM_MODEL_KEY = "ibl_local_llm_model";
+const LOCAL_LLM_TOOL_SUPPORT_KEY = "ibl_local_llm_tool_support";
+/**
+ * The model the user has chosen to chat with (persisted by the Local Models
+ * settings UI), falling back to the default model.
+ */
+function getSelectedModel() {
+    if (typeof window === "undefined")
+        return OLLAMA_MODEL;
+    return localStorage.getItem(LOCAL_LLM_MODEL_KEY) || OLLAMA_MODEL;
+}
+/**
+ * Whether the selected model supports tools / function calling, persisted by the
+ * Local Models settings UI (`setLocalLLMToolSupport` in @iblai/web-containers).
+ * Read directly from localStorage to avoid a web-utils → web-containers import
+ * cycle — same approach as {@link getSelectedModel}.
+ */
+function getSelectedModelToolSupport() {
+    if (typeof window === "undefined")
+        return false;
+    return localStorage.getItem(LOCAL_LLM_TOOL_SUPPORT_KEY) === "true";
+}
 /**
  * Check if running in Tauri
  */
@@ -12449,11 +12541,17 @@ async function streamOllamaChatViaTauri(messages, callbacks, generationId) {
             }
         });
         try {
-            // Call the Tauri command to start streaming
+            const model = getSelectedModel();
+            const toolSupport = getSelectedModelToolSupport();
+            console.log("[LocalLLM] Chatting with model:", model, "toolSupport:", toolSupport);
+            // Call the Tauri command to start streaming. `toolSupport` (→ Rust
+            // `tool_support`) lets the host route to the MCP/tool proxy (:8000) vs
+            // plain Ollama (:11434); the host owns the actual routing decision.
             await invoke("ollama_chat_stream", {
                 messages,
-                model: OLLAMA_MODEL,
+                model,
                 generationId,
+                toolSupport,
             });
         }
         finally {
@@ -12476,13 +12574,19 @@ async function streamOllamaChatViaFetch(messages, callbacks, generationId, abort
     try {
         // Notify start
         callbacks.onStart(generationId);
-        const response = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
+        const model = getSelectedModel();
+        const toolSupport = getSelectedModelToolSupport();
+        // Tool-capable models stream from the MCP/tool proxy (:8000); others from
+        // plain Ollama (:11434).
+        const base = toolSupport ? TOOL_BRIDGE_BASE_URL : OLLAMA_BASE_URL;
+        console.log("[LocalLLM] Chatting with model:", model, "toolSupport:", toolSupport, "via", base);
+        const response = await fetch(`${base}/api/chat`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                model: OLLAMA_MODEL,
+                model,
                 messages,
                 stream: true,
             }),