@trustgraph/react-state 1.7.2 → 2.0.3

package/dist/index.cjs

@@ -150,148 +150,6 @@ const useSessionStore = zustand.create()((set) => ({
     })),
 }));
 
-const useConversation = zustand.create()((set) => ({
-    messages: [],
-    input: "",
-    chatMode: "graph-rag",
-    setMessages: (v) => set(() => ({
-        messages: v,
-    })),
-    addMessage: (role, text, type, explainSessionId) => set((state) => ({
-        messages: [
-            ...state.messages,
-            {
-                role: role,
-                text: text,
-                type: type || "normal",
-                explainSessionId,
-            },
-        ],
-    })),
-    updateLastMessage: (text, explainSessionId) => set((state) => {
-        if (state.messages.length === 0)
-            return state;
-        const messages = [...state.messages];
-        messages[messages.length - 1] = {
-            ...messages[messages.length - 1],
-            text: text,
-            ...(explainSessionId !== undefined && { explainSessionId }),
-        };
-        return { messages };
-    }),
-    setInput: (v) => set(() => ({
-        input: v,
-    })),
-    setChatMode: (mode) => set(() => ({
-        chatMode: mode,
-    })),
-}));
-
-// Zustand state management library for creating stores
-/**
- * Zustand store for managing the main workbench application state
- * Provides centralized state management for tool navigation and entity selection
- */
-const useWorkbenchStateStore = zustand.create()((set) => ({
-    // Initial state values
-    selected: undefined, // No entity selected by default
-    tool: "chat", // Default tool is the chat interface
-    entities: [], // Empty entities list by default
-    // Entity selection functions
-    setSelected: (e) => set(() => ({
-        selected: e,
-    })),
-    // Clear the current entity selection
-    unsetSelected: () => set(() => ({
-        selected: undefined,
-    })),
-    // Tool/page navigation function
-    setTool: (v) => set(() => ({
-        tool: v,
-    })),
-    // Update the list of available entities
-    setEntities: (v) => set(() => ({
-        entities: v,
-    })),
-}));
-
-// Zustand state management library for creating stores
-/**
- * Zustand store for managing document loading state
- * Provides centralized state management for the document upload/loading workflow
- */
-const useLoadStateStore = zustand.create()((set) => ({
-    // Initial state values
-    title: "", // Empty title by default
-    comments: "", // Empty comments by default
-    url: "", // Empty URL by default
-    keywords: [], // No keywords by default
-    operation: "upload-pdf", // Default operation is PDF upload
-    files: [], // No files selected by default
-    uploaded: [], // No files uploaded yet
-    text: "", // Empty text content by default
-    // Setter functions for document metadata
-    setTitle: (v) => set(() => ({
-        title: v,
-    })),
-    setComments: (v) => set(() => ({
-        comments: v,
-    })),
-    setUrl: (v) => set(() => ({
-        url: v,
-    })),
-    setKeywords: (v) => set(() => ({
-        keywords: v,
-    })),
-    // Setter function for processing operation type
-    setOperation: (v) => set(() => ({
-        operation: v,
-    })),
-    // Setter functions for file management
-    setFiles: (v) => set(() => ({
-        files: v,
-    })),
-    setUploaded: (v) => set(() => ({
-        uploaded: v,
-    })),
-    // Add a single file to the uploaded list (preserving existing uploads)
-    addUploaded: (v) => set((state) => ({
-        uploaded: [...state.uploaded, v],
-    })),
-    setText: (v) => set(() => ({
-        text: v,
-    })),
-    // Remove a specific file from the selected files list
-    removeFile: (v) => set((state) => ({
-        files: Array.from(state.files).filter((f) => f != v),
-    })),
-    // Text upload counter management
-    textUploads: 0, // Initial counter value
-    setTextUploads: (v) => set(() => ({
-        textUploads: v,
-    })),
-    // Increment the text upload counter (useful for generating unique IDs)
-    incTextUploads: () => set((state) => ({
-        textUploads: state.textUploads + 1,
-    })),
-}));
-
-// Zustand store for managing search functionality state
-const useSearchStateStore = zustand.create()((set) => ({
-    // Initial state: no search results and empty search input
-    rows: [],
-    input: "",
-    // Replace the entire rows array with new search results
-    // Note: This completely overwrites the previous results
-    setRows: (v) => set(() => ({
-        rows: v,
-    })),
-    // Update the search input string (typically bound to search input field)
-    setInput: (v) => set(() => ({
-        input: v,
-    })),
-}));
-
 const DEFAULT_SETTINGS = {
     user: "trustgraph", // Default user ID
     collection: "default", // Default collection ID
@@ -477,38 +335,485 @@ const useSettings = () => {
     const exportSettings = () => {
         return JSON.stringify(settings, null, 2);
     };
-    // Helper function to import settings from JSON
-    const importSettings = (jsonString) => {
+    // Helper function to import settings from JSON
+    const importSettings = (jsonString) => {
+        try {
+            const imported = JSON.parse(jsonString);
+            const validatedSettings = mergeWithDefaults(imported);
+            saveSettings(validatedSettings);
+        }
+        catch (error) {
+            notify.error("Failed to import settings: Invalid JSON format");
+            throw error;
+        }
+    };
+    // Return the public API for the hook
+    return {
+        // Settings data and state
+        settings,
+        isLoaded: !settingsQuery.isLoading,
+        isLoading: settingsQuery.isLoading,
+        error: settingsQuery.error,
+        // Settings operations
+        updateSetting,
+        saveSettings,
+        resetSettings,
+        exportSettings,
+        importSettings,
+        // Loading states for individual operations
+        isSaving: updateSettingsMutation.isPending,
+        isResetting: resetSettingsMutation.isPending,
+        // Manual refetch function
+        refetch: settingsQuery.refetch,
+    };
+};
+
+// Active workspace is tied to the authenticated session, so it lives in
+// sessionStorage alongside the auth token rather than localStorage.
+const WORKSPACE_STORAGE_KEY = "tg.workspace.active";
+const readSession$1 = () => {
+    try {
+        return sessionStorage.getItem(WORKSPACE_STORAGE_KEY);
+    }
+    catch {
+        return null;
+    }
+};
+const writeSession$1 = (value) => {
+    try {
+        if (value === null)
+            sessionStorage.removeItem(WORKSPACE_STORAGE_KEY);
+        else
+            sessionStorage.setItem(WORKSPACE_STORAGE_KEY, value);
+    }
+    catch {
+        /* ignore */
+    }
+};
+const useWorkspaceStore = zustand.create((set) => ({
+    activeWorkspace: readSession$1(),
+    generation: 0,
+    initActiveWorkspace: (id) => set((s) => {
+        if (s.activeWorkspace)
+            return s;
+        writeSession$1(id);
+        return { activeWorkspace: id };
+    }),
+    setActiveWorkspace: (id) => {
+        writeSession$1(id);
+        set((s) => ({ activeWorkspace: id, generation: s.generation + 1 }));
+    },
+    bumpGeneration: () => set((s) => ({ generation: s.generation + 1 })),
+    clearActiveWorkspace: () => {
+        writeSession$1(null);
+        set({ activeWorkspace: null });
+    },
+}));
+// Discover the workspaces the caller can access (one for an ordinary
+// user, all for an admin — driven entirely by what the gateway returns).
+const useWorkspaces = () => {
+    const socket = reactProvider.useSocket();
+    const connectionState = reactProvider.useConnectionState();
+    const isSocketReady = connectionState?.status === "authenticated";
+    const query = reactQuery.useQuery({
+        queryKey: ["workspaces"],
+        enabled: isSocketReady,
+        queryFn: () => socket.iam().listMyWorkspaces(),
+    });
+    return {
+        workspaces: query.data || [],
+        isLoading: query.isLoading,
+        isError: query.isError,
+        error: query.error,
+        refetch: query.refetch,
+    };
+};
+// The caller's own user record, including their home/default workspace.
+const useWhoami = () => {
+    const socket = reactProvider.useSocket();
+    const connectionState = reactProvider.useConnectionState();
+    const isSocketReady = connectionState?.status === "authenticated";
+    const query = reactQuery.useQuery({
+        queryKey: ["whoami"],
+        enabled: isSocketReady,
+        queryFn: () => socket.iam().whoami(),
+    });
+    return {
+        whoami: query.data,
+        isLoading: query.isLoading,
+        isError: query.isError,
+        error: query.error,
+        refetch: query.refetch,
+    };
+};
+// Bootstrap + keep the socket's outbound workspace in sync. Mount once,
+// high in the tree (e.g. in the authenticated app shell).
+const useWorkspaceSync = () => {
+    const socket = reactProvider.useSocket();
+    const activeWorkspace = useWorkspaceStore((s) => s.activeWorkspace);
+    const initActiveWorkspace = useWorkspaceStore((s) => s.initActiveWorkspace);
+    const setActiveWorkspace = useWorkspaceStore((s) => s.setActiveWorkspace);
+    const { whoami } = useWhoami();
+    const { workspaces } = useWorkspaces();
+    // Until we know the stored workspace is valid, don't stamp it on the
+    // socket — use empty string so the gateway falls back to the token's
+    // default. This prevents a stale/deleted workspace in sessionStorage
+    // from poisoning every request (including the whoami/list calls we
+    // need to detect the problem).
+    const validated = workspaces.length > 0 && activeWorkspace
+        ? workspaces.some((w) => w.id === activeWorkspace)
+        : false;
+    // Adopt the user's default workspace when we have no active one yet.
+    react.useEffect(() => {
+        if (!activeWorkspace && whoami?.default_workspace) {
+            initActiveWorkspace(whoami.default_workspace);
+        }
+    }, [activeWorkspace, whoami, initActiveWorkspace]);
+    // If the stored workspace no longer exists, fall back to the user's
+    // default workspace.
+    react.useEffect(() => {
+        if (!activeWorkspace || !whoami?.default_workspace || workspaces.length === 0)
+            return;
+        if (!validated) {
+            setActiveWorkspace(whoami.default_workspace);
+        }
+    }, [activeWorkspace, workspaces, whoami, validated, setActiveWorkspace]);
+    // Only stamp a validated workspace onto the socket.
+    // Bump generation so hooks that depend on it re-fire with the
+    // workspace now set on the socket.
+    const bumpGeneration = useWorkspaceStore((s) => s.bumpGeneration);
+    react.useEffect(() => {
+        socket.workspace = validated ? activeWorkspace : "";
+        if (validated)
+            bumpGeneration();
+    }, [socket, activeWorkspace, validated, bumpGeneration]);
+};
+// Active workspace + the switcher action for components.
+const useWorkspace = () => {
+    const socket = reactProvider.useSocket();
+    const queryClient = reactQuery.useQueryClient();
+    const activeWorkspace = useWorkspaceStore((s) => s.activeWorkspace);
+    const generation = useWorkspaceStore((s) => s.generation);
+    const setActiveWorkspace = useWorkspaceStore((s) => s.setActiveWorkspace);
+    const setFlowId = useSessionStore((s) => s.setFlowId);
+    const { updateSetting } = useSettings();
+    const { workspaces } = useWorkspaces();
+    const { whoami } = useWhoami();
+    // Switching workspace is a full context reset: collections, flows,
+    // documents and config all re-scope. Reset the inner context (flow +
+    // collection) to defaults and invalidate every cache so all pages
+    // refetch under the new workspace.
+    const switchWorkspace = react.useCallback((id) => {
+        if (!id || id === activeWorkspace)
+            return;
+        // Set synchronously so refetches triggered below already carry it.
+        socket.workspace = id;
+        setActiveWorkspace(id);
+        setFlowId("default");
+        updateSetting("collection", "default");
+        // Wipe workspace-scoped caches so stale data from the previous
+        // workspace can't bleed through, then invalidate to trigger refetches.
+        const keep = ["workspaces", "whoami", "settings"];
+        queryClient.removeQueries({
+            predicate: (q) => !keep.includes(q.queryKey[0]),
+        });
+        queryClient.invalidateQueries();
+    }, [
+        activeWorkspace,
+        socket,
+        setActiveWorkspace,
+        setFlowId,
+        updateSetting,
+        queryClient,
+    ]);
+    return {
+        activeWorkspace,
+        workspaces,
+        defaultWorkspace: whoami?.default_workspace ?? null,
+        generation,
+        switchWorkspace,
+    };
+};
+
+const useConversation = zustand.create()((set) => ({
+    messages: [],
+    input: "",
+    chatMode: "graph-rag",
+    setMessages: (v) => set(() => ({
+        messages: v,
+    })),
+    addMessage: (role, text, type, explainSessionId) => set((state) => ({
+        messages: [
+            ...state.messages,
+            {
+                role: role,
+                text: text,
+                type: type || "normal",
+                explainSessionId,
+            },
+        ],
+    })),
+    updateLastMessage: (text, explainSessionId) => set((state) => {
+        if (state.messages.length === 0)
+            return state;
+        const messages = [...state.messages];
+        messages[messages.length - 1] = {
+            ...messages[messages.length - 1],
+            text: text,
+            ...(explainSessionId !== undefined && { explainSessionId }),
+        };
+        return { messages };
+    }),
+    setInput: (v) => set(() => ({
+        input: v,
+    })),
+    setChatMode: (mode) => set(() => ({
+        chatMode: mode,
+    })),
+}));
+
+// Zustand state management library for creating stores
+/**
+ * Zustand store for managing the main workbench application state
+ * Provides centralized state management for tool navigation and entity selection
+ */
+const useWorkbenchStateStore = zustand.create()((set) => ({
+    // Initial state values
+    selected: undefined, // No entity selected by default
+    tool: "chat", // Default tool is the chat interface
+    entities: [], // Empty entities list by default
+    // Entity selection functions
+    setSelected: (e) => set(() => ({
+        selected: e,
+    })),
+    // Clear the current entity selection
+    unsetSelected: () => set(() => ({
+        selected: undefined,
+    })),
+    // Tool/page navigation function
+    setTool: (v) => set(() => ({
+        tool: v,
+    })),
+    // Update the list of available entities
+    setEntities: (v) => set(() => ({
+        entities: v,
+    })),
+}));
+
+// Zustand state management library for creating stores
+/**
+ * Zustand store for managing document loading state
+ * Provides centralized state management for the document upload/loading workflow
+ */
+const useLoadStateStore = zustand.create()((set) => ({
+    // Initial state values
+    title: "", // Empty title by default
+    comments: "", // Empty comments by default
+    url: "", // Empty URL by default
+    keywords: [], // No keywords by default
+    operation: "upload-pdf", // Default operation is PDF upload
+    files: [], // No files selected by default
+    uploaded: [], // No files uploaded yet
+    text: "", // Empty text content by default
+    // Setter functions for document metadata
+    setTitle: (v) => set(() => ({
+        title: v,
+    })),
+    setComments: (v) => set(() => ({
+        comments: v,
+    })),
+    setUrl: (v) => set(() => ({
+        url: v,
+    })),
+    setKeywords: (v) => set(() => ({
+        keywords: v,
+    })),
+    // Setter function for processing operation type
+    setOperation: (v) => set(() => ({
+        operation: v,
+    })),
+    // Setter functions for file management
+    setFiles: (v) => set(() => ({
+        files: v,
+    })),
+    setUploaded: (v) => set(() => ({
+        uploaded: v,
+    })),
+    // Add a single file to the uploaded list (preserving existing uploads)
+    addUploaded: (v) => set((state) => ({
+        uploaded: [...state.uploaded, v],
+    })),
+    setText: (v) => set(() => ({
+        text: v,
+    })),
+    // Remove a specific file from the selected files list
+    removeFile: (v) => set((state) => ({
+        files: Array.from(state.files).filter((f) => f != v),
+    })),
+    // Text upload counter management
+    textUploads: 0, // Initial counter value
+    setTextUploads: (v) => set(() => ({
+        textUploads: v,
+    })),
+    // Increment the text upload counter (useful for generating unique IDs)
+    incTextUploads: () => set((state) => ({
+        textUploads: state.textUploads + 1,
+    })),
+}));
+
+// Zustand store for managing search functionality state
+const useSearchStateStore = zustand.create()((set) => ({
+    // Initial state: no search results and empty search input
+    rows: [],
+    input: "",
+    // Replace the entire rows array with new search results
+    // Note: This completely overwrites the previous results
+    setRows: (v) => set(() => ({
+        rows: v,
+    })),
+    // Update the search input string (typically bound to search input field)
+    setInput: (v) => set(() => ({
+        input: v,
+    })),
+}));
+
+const TOKEN_STORAGE_KEY = "tg.auth.token";
+const EXPIRES_STORAGE_KEY = "tg.auth.expires";
+const readSession = (key) => {
+    try {
+        return sessionStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+};
+const writeSession = (key, value) => {
+    try {
+        if (value === null)
+            sessionStorage.removeItem(key);
+        else
+            sessionStorage.setItem(key, value);
+    }
+    catch {
+        /* ignore */
+    }
+};
+const initialToken = readSession(TOKEN_STORAGE_KEY);
+const initialExpires = readSession(EXPIRES_STORAGE_KEY);
+const useAuthStore = zustand.create((set) => ({
+    token: initialToken,
+    jwtExpires: initialExpires,
+    status: initialToken ? "authenticated" : "idle",
+    error: null,
+    setToken: (token, expires) => {
+        writeSession(TOKEN_STORAGE_KEY, token);
+        writeSession(EXPIRES_STORAGE_KEY, expires ?? null);
+        set({
+            token,
+            jwtExpires: expires ?? null,
+            status: "authenticated",
+            error: null,
+        });
+    },
+    clearToken: () => {
+        writeSession(TOKEN_STORAGE_KEY, null);
+        writeSession(EXPIRES_STORAGE_KEY, null);
+        set({
+            token: null,
+            jwtExpires: null,
+            status: "idle",
+            error: null,
+        });
+    },
+    setStatus: (status, error) => set({ status, error: error ?? null }),
+}));
+// Module-level AuthApi singleton. Configurable via configureAuthApi() — the
+// demo (or any consumer) can override URLs / fetchImpl before any hook
+// runs.
+let authApiSingleton = client.createAuthApi();
+const configureAuthApi = (options) => {
+    authApiSingleton = client.createAuthApi(options);
+};
+const getAuthApi = () => authApiSingleton;
+const useAuth = () => {
+    const token = useAuthStore((s) => s.token);
+    const jwtExpires = useAuthStore((s) => s.jwtExpires);
+    const status = useAuthStore((s) => s.status);
+    const error = useAuthStore((s) => s.error);
+    return {
+        token,
+        jwtExpires,
+        status,
+        error,
+        isAuthenticated: status === "authenticated" && !!token,
+    };
+};
+const useLogin = () => {
+    const setToken = useAuthStore((s) => s.setToken);
+    const setStatus = useAuthStore((s) => s.setStatus);
+    const status = useAuthStore((s) => s.status);
+    const error = useAuthStore((s) => s.error);
+    const login = react.useCallback(async (username, password, default_workspace) => {
+        setStatus("logging-in", null);
         try {
-            const imported = JSON.parse(jsonString);
-            const validatedSettings = mergeWithDefaults(imported);
-            saveSettings(validatedSettings);
+            const result = await getAuthApi().login(username, password, default_workspace);
+            setToken(result.jwt, result.jwtExpires);
+            return true;
         }
-        catch (error) {
-            notify.error("Failed to import settings: Invalid JSON format");
-            throw error;
+        catch (e) {
+            const message = e instanceof client.AuthError
+                ? e.message
+                : e instanceof Error
+                    ? e.message
+                    : "login failed";
+            setStatus("auth-failed", message);
+            return false;
         }
-    };
-    // Return the public API for the hook
+    }, [setToken, setStatus]);
     return {
-        // Settings data and state
-        settings,
-        isLoaded: !settingsQuery.isLoading,
-        isLoading: settingsQuery.isLoading,
-        error: settingsQuery.error,
-        // Settings operations
-        updateSetting,
-        saveSettings,
-        resetSettings,
-        exportSettings,
-        importSettings,
-        // Loading states for individual operations
-        isSaving: updateSettingsMutation.isPending,
-        isResetting: resetSettingsMutation.isPending,
-        // Manual refetch function
-        refetch: settingsQuery.refetch,
+        login,
+        isLoading: status === "logging-in",
+        error,
     };
 };
+const useLogout = () => {
+    const clearToken = useAuthStore((s) => s.clearToken);
+    return react.useCallback(() => clearToken(), [clearToken]);
+};
+const useBootstrapStatus = () => {
+    const [phase, setPhase] = react.useState("checking");
+    const [error, setError] = react.useState(null);
+    const cancelled = react.useRef(false);
+    const check = react.useCallback(async () => {
+        setPhase("checking");
+        setError(null);
+        try {
+            const result = await getAuthApi().bootstrapStatus();
+            if (cancelled.current)
+                return;
+            setPhase(result.bootstrapAvailable ? "needs-bootstrap" : "normal");
+        }
+        catch (e) {
+            if (cancelled.current)
+                return;
+            const message = e instanceof Error ? e.message : "bootstrap-status failed";
+            // Distinguish "service unreachable" (likely pre-bootstrap or down)
+            // from other errors. The IAM spec doesn't define a separate signal
+            // for pre-bootstrap, so we treat any failure to reach the endpoint
+            // as pre-bootstrap territory and let the operator interpret.
+            setError(message);
+            setPhase("pre-bootstrap");
+        }
+    }, []);
+    react.useEffect(() => {
+        cancelled.current = false;
+        check();
+        return () => {
+            cancelled.current = true;
+        };
+    }, [check]);
+    return { phase, error, refetch: check };
+};
 
 /**
  * Custom hook for managing flow operations
@@ -524,8 +829,7 @@ const useFlows = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all flows
      * Uses React Query for caching and background refetching
@@ -746,8 +1050,7 @@ const useLibrary = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all documents from the library
      * Uses React Query for caching and background refetching
@@ -916,57 +1219,35 @@ const useLibrary = () => {
     };
 };
 
-// @ts-nocheck
-/**
- * Custom hook for managing token cost operations
- * Provides functionality for fetching, deleting, and updating token costs
- * for AI models
- * @returns {Object} Token cost state and operations
- */
 const useTriples = ({ flow, s, p, o, limit, collection }) => {
-    // WebSocket connection for communicating with the configuration service
     const socket = reactProvider.useSocket();
-    // Hook for displaying user notifications
     const notify = useNotification();
-    // Settings for default collection
     const { settings } = useSettings();
-    // Session state for default flow ID
+    const connectionState = reactProvider.useConnectionState();
+    const isSocketReady = connectionState?.status === "authenticated";
     const sessionFlowId = useSessionStore((state) => state.flowId);
-    // Use explicit param if provided, otherwise fall back to session state
     const effectiveFlow = flow ?? sessionFlowId;
-    /**
-     * Query for fetching all token costs
-     * Uses React Query for caching and background refetching
-     */
+    const effectiveCollection = collection || settings.collection;
     const query = reactQuery.useQuery({
-        queryKey: ["triples", { flow: effectiveFlow, s, p, o, limit }],
+        queryKey: ["triples", { flow: effectiveFlow, s, p, o, limit, collection: effectiveCollection }],
+        enabled: isSocketReady,
         queryFn: () => {
             return socket
                 .flow(effectiveFlow)
-                .triplesQuery(s, p, o, limit, collection || settings.collection)
-                .then((x) => {
-                if (x["error"]) {
-                    console.log("Error:", x);
-                    throw x.error.message;
-                }
-                return x;
-            })
+                .triplesQuery(s, p, o, limit, effectiveCollection)
                 .catch((err) => {
-                console.log("Error:", err);
-                notify.error(err);
+                const message = err instanceof Error ? err.message : String(err);
+                notify.error(message);
+                throw err;
             });
         },
     });
-    // Show loading indicators for long-running operations
     useActivity(query.isLoading, "Loading triples");
-    // Return token cost state and operations for use in components
     return {
-        // Token cost query state
-        triples: query.data,
+        triples: (query.data ?? []),
         isLoading: query.isLoading,
         isError: query.isError,
         error: query.error,
-        // Manual refetch function
         refetch: query.refetch,
     };
 };
@@ -1922,11 +2203,13 @@ const useExplainabilityStore = zustand.create()((set, get) => ({
 /**
  * Explainability utilities for parsing and structuring explain events
  */
-// Agent-specific predicates (not yet in client library)
+// Predicates not yet in client library
 const TG_ACTION = client.TG + "action";
 const TG_ARGUMENTS = client.TG + "arguments";
 const TG_SUBAGENT_GOAL = client.TG + "subagentGoal";
-// RDF type URIs for agent events
+const TG_CONCEPT = client.TG_CONCEPT;
+const TG_ENTITY = client.TG + "entity";
+// RDF type URIs
 const TG_AGENT_QUESTION = client.TG + "AgentQuestion";
 const TG_ANALYSIS = client.TG + "Analysis";
 const TG_TOOL_USE = client.TG + "ToolUse";
@@ -1934,13 +2217,14 @@ const TG_OBSERVATION = client.TG + "Observation";
 const TG_THOUGHT_TYPE = client.TG + "Thought";
 const TG_REFLECTION_TYPE = client.TG + "Reflection";
 const TG_CONCLUSION = client.TG + "Conclusion";
-const TG_ANSWER = client.TG + "Answer";
 const TG_FINDING = client.TG + "Finding";
-const TG_SYNTHESIS_TYPE = client.TG + "Synthesis";
 const TG_DECOMPOSITION = client.TG + "Decomposition";
+const TG_GROUNDING = client.TG + "Grounding";
+const TG_EXPLORATION_TYPE = client.TG + "Exploration";
+const TG_FOCUS_TYPE = client.TG + "Focus";
 // ── Helpers ─────────────────────────────────────────────────────────
 /**
- * Extract event type from explainId URI (graph-rag only)
+ * Extract event type from explainId URI (graph-rag fallback)
  */
 function getEventType(explainId) {
     if (explainId.includes("question"))
@@ -1953,9 +2237,6 @@ function getEventType(explainId) {
         return "synthesis";
     return "unknown";
 }
-/**
- * Get term value from a Term object
- */
 function getTermValue$1(term) {
     if (!term)
         return "";
@@ -1964,7 +2245,6 @@ function getTermValue$1(term) {
     if (term.t === "l")
         return term.v || "";
     if (term.t === "t" && term.tr) {
-        // Quoted triple - return a serialized form
         const s = getTermValue$1(term.tr.s);
         const p = getTermValue$1(term.tr.p);
         const o = getTermValue$1(term.tr.o);
@@ -1972,9 +2252,6 @@ function getTermValue$1(term) {
     }
     return "";
 }
-/**
- * Extract quoted triple from a Term
- */
 function extractQuotedTriple(term) {
     if (term.t === "t" && term.tr) {
         return {
@@ -1985,9 +2262,15 @@ function extractQuotedTriple(term) {
     }
     return null;
 }
-// ── Agent event type detection ──────────────────────────────────────
-/** Map RDF type URI → agent event type (first match wins) */
-const AGENT_TYPE_CHECKS = [
+// ── RDF type detection ──────────────────────────────────────────────
+/**
+ * Map RDF type URI → event type (first match wins).
+ * Agent-specific types only — shared types like tg:Synthesis and
+ * tg:Answer are excluded to avoid catching graph-rag events.
+ * Grounding, Exploration, Focus are included since they now carry
+ * embedded triples with their RDF type.
+ */
+const RDF_TYPE_CHECKS = [
     [TG_AGENT_QUESTION, "agent-question"],
     [TG_DECOMPOSITION, "decomposition"],
     [TG_ANALYSIS, "analysis"],
@@ -1997,12 +2280,12 @@ const AGENT_TYPE_CHECKS = [
     [TG_REFLECTION_TYPE, "reflection"],
     [TG_CONCLUSION, "conclusion"],
     [TG_FINDING, "conclusion"],
-    [TG_SYNTHESIS_TYPE, "conclusion"],
-    [TG_ANSWER, "conclusion"],
+    [TG_GROUNDING, "grounding"],
+    [TG_EXPLORATION_TYPE, "exploration"],
+    [TG_FOCUS_TYPE, "focus"],
 ];
 /**
  * Detect event type from RDF types in embedded triples.
- * Returns an agent event type if matched, "unknown" otherwise.
  */
 function getEventTypeFromTriples(triples) {
     const types = new Set();
@@ -2011,7 +2294,7 @@ function getEventTypeFromTriples(triples) {
             types.add(getTermValue$1(t.o));
         }
     }
-    for (const [typeUri, eventType] of AGENT_TYPE_CHECKS) {
+    for (const [typeUri, eventType] of RDF_TYPE_CHECKS) {
         if (types.has(typeUri))
             return eventType;
     }
@@ -2031,38 +2314,69 @@ function extractCommonFields(triples) {
     }
     return { label, derivedFrom };
 }
-// ── Graph-RAG parsers (existing) ────────────────────────────────────
+/**
+ * Extract inline edges from triples (tg:edge quoted triples + concept/score).
+ * Groups by edge selection subject URI to associate edge, concept, and score.
+ * Returns SelectedEdge objects with URIs — labels resolved later.
+ */
+function extractInlineEdges(triples) {
+    const bySubject = new Map();
+    for (const t of triples) {
+        const s = getTermValue$1(t.s);
+        const p = getTermValue$1(t.p);
+        if (p === client.TG_EDGE && t.o.t === "t" && t.o.tr) {
+            const edge = extractQuotedTriple(t.o);
+            if (edge) {
+                const existing = bySubject.get(s) || { edge };
+                existing.edge = edge;
+                bySubject.set(s, existing);
+            }
+        }
+        else if (p === TG_CONCEPT) {
+            const concept = getTermValue$1(t.o);
+            if (concept) {
+                const existing = bySubject.get(s) || { edge: { s: "", p: "", o: "" } };
+                existing.concept = concept;
+                bySubject.set(s, existing);
+            }
+        }
+        else if (p === client.TG_SCORE) {
+            const scoreStr = getTermValue$1(t.o);
+            if (scoreStr) {
+                const existing = bySubject.get(s) || { edge: { s: "", p: "", o: "" } };
+                existing.score = parseFloat(scoreStr);
+                bySubject.set(s, existing);
+            }
+        }
+    }
+    return Array.from(bySubject.values()).filter(se => se.edge.s !== "");
+}
+// ── Parsers ─────────────────────────────────────────────────────────
 function parseQuestionTriples(explainId, explainGraph, triples) {
-    const event = {
-        type: "question",
-        explainId,
-        explainGraph,
-    };
-    for (const triple of triples) {
-        const p = getTermValue$1(triple.p);
-        const o = getTermValue$1(triple.o);
-        if (p === client.TG_QUERY) {
+    const event = { type: "question", explainId, explainGraph };
+    for (const t of triples) {
+        const p = getTermValue$1(t.p);
+        const o = getTermValue$1(t.o);
+        if (p === client.TG_QUERY)
             event.query = o;
-        }
-        else if (p === client.PROV_STARTED_AT_TIME) {
+        else if (p === client.PROV_STARTED_AT_TIME)
             event.timestamp = o;
-        }
     }
     return event;
 }
 function parseExplorationTriples(explainId, explainGraph, triples) {
-    const event = {
-        type: "exploration",
-        explainId,
-        explainGraph,
-    };
-    for (const triple of triples) {
-        const p = getTermValue$1(triple.p);
-        const o = getTermValue$1(triple.o);
-        if (p === client.TG_EDGE_COUNT) {
+    const event = { type: "exploration", explainId, explainGraph };
+    const entities = [];
+    for (const t of triples) {
+        const p = getTermValue$1(t.p);
+        const o = getTermValue$1(t.o);
+        if (p === client.TG_EDGE_COUNT)
             event.edgeCount = parseInt(o, 10);
-        }
+        if (p === TG_ENTITY && o)
+            entities.push(o);
     }
+    if (entities.length > 0)
+        event.entities = entities;
     return event;
 }
 function parseFocusTriples(explainId, explainGraph, triples) {
@@ -2072,53 +2386,64 @@ function parseFocusTriples(explainId, explainGraph, triples) {
         explainGraph,
         edgeSelectionUris: [],
     };
-    for (const triple of triples) {
-        const p = getTermValue$1(triple.p);
-        const o = getTermValue$1(triple.o);
+    // Collect edge selection URIs (old format)
+    for (const t of triples) {
+        const p = getTermValue$1(t.p);
+        const o = getTermValue$1(t.o);
         if (p === client.TG_SELECTED_EDGE && typeof o === "string") {
             event.edgeSelectionUris.push(o);
         }
     }
+    // Extract inline edges (new format: tg:edge with quoted triples)
+    const inlineEdges = extractInlineEdges(triples);
+    if (inlineEdges.length > 0) {
+        event.selectedEdges = inlineEdges;
+    }
     return event;
 }
 function parseSynthesisTriples(explainId, explainGraph, triples) {
-    const event = {
-        type: "synthesis",
-        explainId,
-        explainGraph,
-    };
-    for (const triple of triples) {
-        const p = getTermValue$1(triple.p);
-        const o = getTermValue$1(triple.o);
-        if (p === client.TG_CONTENT) {
+    const event = { type: "synthesis", explainId, explainGraph };
+    for (const t of triples) {
+        const p = getTermValue$1(t.p);
+        const o = getTermValue$1(t.o);
+        if (p === client.TG_CONTENT)
             event.contentLength = o.length;
-        }
     }
     return event;
 }
 function parseEdgeSelectionTriples(triples) {
     let edge = null;
-    let reasoning = null;
+    let concept = null;
+    let score = null;
     for (const triple of triples) {
         const p = getTermValue$1(triple.p);
-        if (p === client.TG_EDGE) {
+        if (p === client.TG_EDGE)
             edge = extractQuotedTriple(triple.o);
+        else if (p === TG_CONCEPT)
+            concept = getTermValue$1(triple.o);
+        else if (p === client.TG_SCORE) {
+            const v = getTermValue$1(triple.o);
+            if (v)
+                score = parseFloat(v);
         }
-        else if (p === client.TG_REASONING) {
-            reasoning = getTermValue$1(triple.o);
-        }
     }
-    return { edge, reasoning };
+    return { edge, concept, score };
+}
+function parseGroundingTriples(explainId, explainGraph, triples) {
+    const { label, derivedFrom } = extractCommonFields(triples);
+    const concepts = [];
+    for (const t of triples) {
+        const p = getTermValue$1(t.p);
+        const o = getTermValue$1(t.o);
+        if (p === TG_CONCEPT && o)
+            concepts.push(o);
+    }
+    return { type: "grounding", explainId, explainGraph, label, concepts, derivedFrom };
 }
-// ── Agent parsers (new) ─────────────────────────────────────────────
 function parseAgentQuestionTriples(explainId, explainGraph, triples) {
     const { label, derivedFrom } = extractCommonFields(triples);
     const event = {
-        type: "agent-question",
-        explainId,
-        explainGraph,
-        label,
-        derivedFrom,
+        type: "agent-question", explainId, explainGraph, label, derivedFrom,
     };
     for (const t of triples) {
         const p = getTermValue$1(t.p);
@@ -2139,23 +2464,12 @@ function parseDecompositionTriples(explainId, explainGraph, triples) {
         if (p === TG_SUBAGENT_GOAL && o)
             goals.push(o);
     }
-    return {
-        type: "decomposition",
-        explainId,
-        explainGraph,
-        label,
-        goals,
-        derivedFrom,
-    };
+    return { type: "decomposition", explainId, explainGraph, label, goals, derivedFrom };
 }
 function parseAnalysisTriples(explainId, explainGraph, triples) {
     const { label, derivedFrom } = extractCommonFields(triples);
     const event = {
-        type: "analysis",
-        explainId,
-        explainGraph,
-        label,
-        derivedFrom,
+        type: "analysis", explainId, explainGraph, label, derivedFrom,
     };
     for (const t of triples) {
         const p = getTermValue$1(t.p);
@@ -2169,34 +2483,22 @@ function parseAnalysisTriples(explainId, explainGraph, triples) {
 }
 function parseReflectionTriples(explainId, explainGraph, triples) {
     const { label, derivedFrom } = extractCommonFields(triples);
-    return {
-        type: "reflection",
-        explainId,
-        explainGraph,
-        label,
-        derivedFrom,
-    };
+    return { type: "reflection", explainId, explainGraph, label, derivedFrom };
 }
 function parseConclusionTriples(explainId, explainGraph, triples) {
     const { label, derivedFrom } = extractCommonFields(triples);
-    return {
-        type: "conclusion",
-        explainId,
-        explainGraph,
-        label,
-        derivedFrom,
-    };
+    return { type: "conclusion", explainId, explainGraph, label, derivedFrom };
 }
 // ── Unified parser ──────────────────────────────────────────────────
 /**
  * Parse triples into a structured event.
- * Tries RDF type detection first (agent events), then URI patterns (graph-rag).
- * Returns null for events with no triples (inner graph-rag plumbing).
+ * Tries RDF type detection first, then URI patterns as fallback.
+ * Returns null for events with no triples.
  */
 function parseExplainTriples(explainId, explainGraph, triples) {
     if (triples.length === 0)
         return null;
-    // Try RDF type detection first (agent events with embedded triples)
+    // Try RDF type detection first
     const rdfEventType = getEventTypeFromTriples(triples);
     if (rdfEventType !== "unknown") {
         switch (rdfEventType) {
@@ -2210,6 +2512,12 @@ function parseExplainTriples(explainId, explainGraph, triples) {
                 return parseReflectionTriples(explainId, explainGraph, triples);
             case "conclusion":
                 return parseConclusionTriples(explainId, explainGraph, triples);
+            case "grounding":
+                return parseGroundingTriples(explainId, explainGraph, triples);
+            case "exploration":
+                return parseExplorationTriples(explainId, explainGraph, triples);
+            case "focus":
+                return parseFocusTriples(explainId, explainGraph, triples);
         }
     }
     // Fall back to URI pattern detection (graph-rag events)
@@ -2230,8 +2538,10 @@ function parseExplainTriples(explainId, explainGraph, triples) {
 
 /**
  * Hook for tracing provenance chains in the knowledge graph
- * Follows prov:wasDerivedFrom relationships from any entity to its source documents
+ * Follows tg:contains to find subgraphs, then prov:wasDerivedFrom
+ * to trace chunk → page → document chains
  */
+const TG_CONTAINS = client.TG + "contains";
 /**
  * Hook for tracing provenance chains
  */
@@ -2248,8 +2558,7 @@ const useProvenance = (options = {}) => {
      * Check if connected
      */
     const isConnected = react.useCallback(() => {
-        return (connectionState?.status === "authenticated" ||
-            connectionState?.status === "unauthenticated");
+        return (connectionState?.status === "authenticated");
     }, [connectionState]);
     /**
      * Query for rdfs:label of a URI
@@ -2328,13 +2637,13 @@ const useProvenance = (options = {}) => {
         }
     }, [maxDepth, resolveLabel, queryDerivedFrom]);
     /**
-     * Query for statements that reify an edge via tg:reifies
+     * Find subgraphs that contain an edge via tg:contains with a quoted triple
      */
-    const queryReifyingStatements = react.useCallback(async (s, p, o) => {
+    const queryContainingSubgraphs = react.useCallback(async (s, p, o) => {
         if (!isConnected())
             return [];
         try {
-            // Build the quoted triple term
+            // Build the quoted triple term for the edge
             const quotedTriple = {
                 t: "t",
                 tr: {
@@ -2347,7 +2656,7 @@ const useProvenance = (options = {}) => {
             };
             const triples = await socket
                 .flow(effectiveFlow)
-                .triplesQuery(undefined, { t: "i", i: client.TG_REIFIES }, quotedTriple, 10, collection);
+                .triplesQuery(undefined, { t: "i", i: TG_CONTAINS }, quotedTriple, 10, collection);
             return triples.map((t) => getTermValue$1(t.s));
         }
         catch {
@@ -2355,20 +2664,21 @@ const useProvenance = (options = {}) => {
         }
     }, [socket, effectiveFlow, collection, isConnected]);
     /**
-     * Trace provenance for an edge - finds reifying statements and traces each
+     * Trace provenance for an edge — find containing subgraph, then follow
+     * wasDerivedFrom chain: subgraph → chunk → page → document
      */
     const traceEdgeProvenance = react.useCallback(async (s, p, o) => {
         setIsTracing(true);
         try {
-            // Find statements that reify this edge
-            const stmtUris = await queryReifyingStatements(s, p, o);
-            // For each reifying statement, trace its provenance chain
+            // Find subgraphs containing this edge
+            const subgraphUris = await queryContainingSubgraphs(s, p, o);
             const chains = [];
-            for (const stmtUri of stmtUris) {
-                // Get the wasDerivedFrom source for this statement
-                const sourceUri = await queryDerivedFrom(stmtUri);
-                if (sourceUri) {
-                    const chain = await traceChain(sourceUri);
+            for (const subgraphUri of subgraphUris) {
+                // Follow wasDerivedFrom from the subgraph to the chunk
+                const chunkUri = await queryDerivedFrom(subgraphUri);
+                if (chunkUri) {
+                    // Trace the full chain from chunk upward
+                    const chain = await traceChain(chunkUri);
                     chains.push(chain);
                 }
             }
@@ -2377,7 +2687,7 @@ const useProvenance = (options = {}) => {
         finally {
             setIsTracing(false);
         }
-    }, [queryReifyingStatements, queryDerivedFrom, traceChain]);
+    }, [queryContainingSubgraphs, queryDerivedFrom, traceChain]);
     /**
      * Clear the label cache
      */
@@ -2434,12 +2744,13 @@ const useExplainability = (options = {}) => {
     const resolveEdge = react.useCallback(async (edgeSelUri, allTriples) => {
         // Filter embedded triples for this edge selection URI
         const edgeTriples = allTriples.filter((t) => getTermValue$1(t.s) === edgeSelUri);
-        const { edge, reasoning } = parseEdgeSelectionTriples(edgeTriples);
+        const { edge, concept, score } = parseEdgeSelectionTriples(edgeTriples);
         if (!edge)
             return null;
         const selectedEdge = {
             edge,
-            reasoning: reasoning || undefined,
+            concept: concept || undefined,
+            score: score ?? undefined,
         };
         // Kick off label resolution and provenance in parallel
         const [labels, provenanceChains] = await Promise.all([
@@ -2479,56 +2790,82 @@ const useExplainability = (options = {}) => {
         setSession(updater);
         onUpdateRef.current?.(sessionRef.current);
     }, []);
-    const AGENT_EVENT_TYPES = new Set([
+    const AGENT_STEP_TYPES = new Set([
         "agent-question", "decomposition", "analysis", "reflection", "conclusion",
+        "grounding",
     ]);
+    /**
+     * Resolve labels for inline edges (edges already extracted, just need labels)
+     */
+    const resolveEdgeLabels = react.useCallback(async (focusEvent) => {
+        if (!focusEvent.selectedEdges || focusEvent.selectedEdges.length === 0) {
+            return focusEvent;
+        }
+        const resolved = await Promise.all(focusEvent.selectedEdges.map(async (se) => {
+            const [sLabel, pLabel, oLabel] = await Promise.all([
+                resolveLabel(se.edge.s),
+                resolveLabel(se.edge.p),
+                resolveLabel(se.edge.o),
+            ]);
+            let sources;
+            if (traceProvenance) {
+                const chains = await traceEdgeProvenance(se.edge.s, se.edge.p, se.edge.o);
+                if (chains.length > 0) {
+                    sources = chains.map((c) => c.chain).flat();
+                }
+            }
+            return {
+                ...se,
+                labels: { s: sLabel, p: pLabel, o: oLabel },
+                sources,
+            };
+        }));
+        return { ...focusEvent, selectedEdges: resolved };
+    }, [resolveLabel, traceProvenance, traceEdgeProvenance]);
     /**
      * Process a single explain event
      */
     const processEvent = react.useCallback(async (event) => {
-        // Use embedded triples directly from the event
         const triples = event.explainTriples ?? [];
-        // Parse into structured data
         const parsed = parseExplainTriples(event.explainId, event.explainGraph, triples);
         if (!parsed)
             return;
-        if (AGENT_EVENT_TYPES.has(parsed.type)) {
-            // Agent event — append to timeline
+        if (AGENT_STEP_TYPES.has(parsed.type)) {
+            // Agent step — append to timeline
             updateSession((prev) => ({
                 ...prev,
                 agentSteps: [...(prev.agentSteps || []), parsed],
             }));
         }
-        else {
-            // Graph-RAG event — populate fixed fields
-            updateSession((prev) => {
-                const next = { ...prev };
-                switch (parsed.type) {
-                    case "question":
-                        next.question = parsed;
-                        break;
-                    case "exploration":
-                        next.exploration = parsed;
-                        break;
-                    case "focus":
-                        next.focus = parsed;
-                        break;
-                    case "synthesis":
-                        next.synthesis = parsed;
-                        break;
+        // Graph-RAG fields — populate regardless (agent produces these too)
+        switch (parsed.type) {
+            case "question":
+                updateSession((prev) => ({ ...prev, question: parsed }));
+                break;
+            case "exploration":
+                updateSession((prev) => ({ ...prev, exploration: parsed }));
+                break;
+            case "focus": {
+                updateSession((prev) => ({ ...prev, focus: parsed }));
+                // Resolve labels for inline edges, or unpack old-format edges
+                const focusEvent = parsed;
+                if (focusEvent.selectedEdges && focusEvent.selectedEdges.length > 0) {
+                    // New format: edges already extracted, resolve labels
+                    const resolved = await resolveEdgeLabels(focusEvent);
+                    updateSession((prev) => ({ ...prev, focus: resolved }));
                 }
-                return next;
-            });
-            // For focus events, unpack edges (labels still need store lookup)
-            if (parsed.type === "focus") {
-                const unpackedFocus = await unpackFocusEvent(parsed, triples);
-                updateSession((prev) => ({
-                    ...prev,
-                    focus: unpackedFocus,
-                }));
+                else if (focusEvent.edgeSelectionUris.length > 0) {
+                    // Old format: unpack edge selection URIs
+                    const unpacked = await unpackFocusEvent(focusEvent, triples);
+                    updateSession((prev) => ({ ...prev, focus: unpacked }));
+                }
+                break;
             }
+            case "synthesis":
+                updateSession((prev) => ({ ...prev, synthesis: parsed }));
+                break;
         }
-    }, [unpackFocusEvent, updateSession]);
+    }, [unpackFocusEvent, resolveEdgeLabels, updateSession]);
     /**
      * Process the unpack queue
      */
@@ -2893,8 +3230,7 @@ const useStructuredQuery = () => {
     // Settings for default collection
     const { settings } = useSettings();
     // Only enable operations when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Mutation for executing structured queries from natural language
     const structuredQueryMutation = reactQuery.useMutation({
         mutationFn: async ({ question, collection, }) => {
@@ -2950,8 +3286,7 @@ const useRowEmbeddingsQuery = ({ flow } = {}) => {
     const sessionFlowId = useSessionStore((state) => state.flowId);
     const { settings } = useSettings();
     const effectiveFlow = flow ?? sessionFlowId;
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const mutation = reactQuery.useMutation({
         mutationFn: async ({ vectors, schemaName, collection, indexName, limit = 10, }) => {
             if (!isSocketReady) {
@@ -2991,8 +3326,7 @@ const useDocumentEmbeddingsQuery = ({ flow } = {}) => {
     const sessionFlowId = useSessionStore((state) => state.flowId);
     const { settings } = useSettings();
     const effectiveFlow = flow ?? sessionFlowId;
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const mutation = reactQuery.useMutation({
         mutationFn: async ({ vectors, user, collection, limit = 10, }) => {
             if (!isSocketReady) {
@@ -3038,8 +3372,7 @@ const useRowsQuery = ({ flow } = {}) => {
     // Settings for default collection
     const { settings } = useSettings();
     // Only enable operations when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Mutation for executing GraphQL rows queries
     const rowsQueryMutation = reactQuery.useMutation({
         mutationFn: async ({ query, collection, variables, operationName, }) => {
@@ -3088,8 +3421,7 @@ const useEmbeddings = ({ flow, term }) => {
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Hook for displaying user notifications
     const notify = useNotification();
     // Session state for default flow ID
@@ -3147,8 +3479,7 @@ const useCollections = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all collections from the collection management service
      * Uses React Query for caching and background refetching
@@ -3252,8 +3583,7 @@ const useNlpQuery = ({ flow } = {}) => {
     // Use explicit param if provided, otherwise fall back to session state
     const effectiveFlow = flow ?? sessionFlowId;
     // Only enable operations when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Mutation for converting natural language to GraphQL
     const nlpQueryMutation = reactQuery.useMutation({
         mutationFn: async ({ question, maxResults, }) => {
@@ -3303,8 +3633,7 @@ const useProcessing = () => {
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all processing
      * Uses React Query for caching and background refetching
@@ -3347,8 +3676,7 @@ const useAgentTools = () => {
     // Notification system for user feedback
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Query to fetch all agent tools
     // Gets all tools directly from the 'tool' configuration type
     const toolsQuery = reactQuery.useQuery({
@@ -3510,8 +3838,7 @@ const useMcpTools = () => {
     // Notification system for user feedback
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Query to fetch all MCP tools
     // Uses the list operation to get all MCP tools directly
     const toolsQuery = reactQuery.useQuery({
@@ -3670,8 +3997,7 @@ const usePrompts = () => {
     // Notification system for user feedback
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Query to fetch the system prompt configuration
     // System prompt defines the AI assistant's behavior and instructions
     const systemPromptQuery = reactQuery.useQuery({
@@ -3691,22 +4017,21 @@ const usePrompts = () => {
         },
     });
     // Query to fetch all prompt templates
-    // First gets the template index (list of template IDs), then fetches each template's configuration
+    // Lists prompt config keys, filters for template.* prefix, then fetches each template's configuration
     const promptsQuery = reactQuery.useQuery({
         queryKey: ["prompts"],
         enabled: isSocketReady,
         queryFn: () => {
-            // Step 1: Get the template index (array of template IDs)
             return socket
                 .config()
-                .getConfig([{ type: "prompt", key: "template-index" }])
+                .list("prompt")
                 .then((res) => {
-                if (res["error"]) {
-                    console.log("Error:", res);
-                    throw res.error.message;
-                }
-                const promptIds = JSON.parse(res.values[0].value);
-                // Step 2: Fetch configuration for each template using their IDs
+                const keys = res?.directory || [];
+                const promptIds = keys
+                    .filter((k) => k.startsWith("template."))
+                    .map((k) => k.slice("template.".length));
+                if (promptIds.length === 0)
+                    return [];
                 return socket
                     .config()
                     .getConfig(promptIds.map((id) => ({
@@ -3718,7 +4043,6 @@ const usePrompts = () => {
                         console.log("Error:", r);
                         throw r.error.message;
                     }
-                    // Parse template configurations and pair them with their IDs
                     const config = r.values.map((c) => JSON.parse(c.value));
                     return promptIds.map((id, ix) => [id, config[ix]]);
                 });
@@ -3791,41 +4115,24 @@ const usePrompts = () => {
         },
     });
     // Mutation for creating a new prompt template
-    // Updates both the template index and creates the template configuration
     const createPromptMutation = reactQuery.useMutation({
         mutationFn: ({ id, prompt, onSuccess }) => {
-            // Step 1: Get current template index
             return socket
                 .config()
-                .getConfig([{ type: "prompt", key: "template-index" }])
-                .then((res) => JSON.parse(res.values[0].value))
-                .then((existingIds) => {
-                // Step 2: Add new template ID to the index
-                const newIds = [...existingIds, id];
-                // Step 3: Update both the template index and create the new template configuration
-                return socket
-                    .config()
-                    .putConfig([
-                    {
-                        type: "prompt",
-                        key: "template-index",
-                        value: JSON.stringify(newIds),
-                    },
-                    {
-                        type: "prompt",
-                        key: "template." + id,
-                        value: JSON.stringify(prompt),
-                    },
-                ])
-                    .then((x) => {
-                    if (x["error"]) {
-                        console.log("Error:", x);
-                        throw x.error.message;
-                    }
-                    // Execute callback if provided
-                    if (onSuccess)
-                        onSuccess();
-                });
+                .putConfig([
+                {
+                    type: "prompt",
+                    key: "template." + id,
+                    value: JSON.stringify(prompt),
+                },
+            ])
+                .then((x) => {
+                if (x["error"]) {
+                    console.log("Error:", x);
+                    throw x.error.message;
+                }
+                if (onSuccess)
+                    onSuccess();
             });
         },
         onError: (err) => {
@@ -3839,45 +4146,21 @@ const usePrompts = () => {
         },
     });
     // Mutation for deleting a prompt template
-    // Removes the template from both the index and deletes its configuration
     const deletePromptMutation = reactQuery.useMutation({
         mutationFn: ({ id, onSuccess }) => {
-            // Step 1: Get current template index
             return socket
                 .config()
-                .getConfig([{ type: "prompt", key: "template-index" }])
-                .then((res) => JSON.parse(res.values[0].value))
-                .then((existingIds) => {
-                // Step 2: Remove the template ID from the index
-                const newIds = existingIds.filter((existingId) => existingId !== id);
-                // Step 3: Update the template index
-                return socket
-                    .config()
-                    .putConfig([
-                    {
-                        type: "prompt",
-                        key: "template-index",
-                        value: JSON.stringify(newIds),
-                    },
-                ])
-                    .then(() => {
-                    // Step 4: Delete the template configuration
-                    return socket.config().deleteConfig([
-                        {
-                            type: "prompt",
-                            key: "template." + id,
-                        },
-                    ]);
-                })
-                    .then((x) => {
-                    if (x["error"]) {
-                        console.log("Error:", x);
-                        throw x.error.message;
-                    }
-                    // Execute callback if provided
-                    if (onSuccess)
-                        onSuccess();
-                });
+                .deleteConfig({
+                type: "prompt",
+                key: "template." + id,
+            })
+                .then((x) => {
+                if (x["error"]) {
+                    console.log("Error:", x);
+                    throw x.error.message;
+                }
+                if (onSuccess)
+                    onSuccess();
             });
         },
         onError: (err) => {
@@ -3932,8 +4215,7 @@ const useSchemas = () => {
     const queryClient = reactQuery.useQueryClient();
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const schemasQuery = reactQuery.useQuery({
         queryKey: ["schemas"],
         enabled: isSocketReady,
@@ -4063,8 +4345,7 @@ const useOntologies = () => {
     const queryClient = reactQuery.useQueryClient();
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const ontologiesQuery = reactQuery.useQuery({
         queryKey: ["ontologies"],
         enabled: isSocketReady,
@@ -4202,8 +4483,7 @@ const useKnowledgeCores = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all knowledge cores
      * Uses React Query for caching and background refetching
@@ -4305,8 +4585,7 @@ const useTokenCosts = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all token costs
      * Uses React Query for caching and background refetching
@@ -4437,8 +4716,7 @@ const useLLMModels = () => {
     const connectionState = reactProvider.useConnectionState();
     const queryClient = reactQuery.useQueryClient();
     const notify = useNotification();
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     // Fetch the llm-model parameter type
     const paramTypesQuery = reactQuery.useQuery({
         queryKey: ["llm-models"],
@@ -4524,8 +4802,7 @@ const useFlowBlueprints = () => {
     // Hook for displaying user notifications
     const notify = useNotification();
     // Only enable queries when socket is connected and ready
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching all flow blueprintes
      * Uses React Query for caching and background refetching
@@ -4798,8 +5075,7 @@ const generateFlowBlueprintId = (baseName = "flow-class") => {
 const useFlowParameters = (flowBlueprintName) => {
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     /**
      * Query for fetching parameter definitions for a flow blueprint
      */
@@ -5428,8 +5704,9 @@ const useNodeDetails = (nodeId, flowId) => {
     };
 };
 
-// Default chunk size: 5MB (matches backend default)
-const DEFAULT_CHUNK_SIZE$1 = 5 * 1024 * 1024;
+// Default chunk size: 2MB (base64 + JSON encoding inflates ~4x on the wire,
+// Pulsar message limit is around 3MB raw)
+const DEFAULT_CHUNK_SIZE$1 = 2 * 1024 * 1024;
 // Maximum parallel chunk uploads
 const DEFAULT_PARALLEL_UPLOADS = 3;
 /**
@@ -5546,8 +5823,7 @@ const useChunkedUpload = (options = {}) => {
     const upload = react.useCallback(async (params) => {
         const { file, title, comments = "", tags = [], collection, documentId } = params;
         // Validate connection
-        if (connectionState?.status !== "authenticated" &&
-            connectionState?.status !== "unauthenticated") {
+        if (connectionState?.status !== "authenticated") {
             const error = "Not connected to server";
             updateProgress({ status: "error", error });
             onError?.(error);
@@ -5638,8 +5914,7 @@ const useChunkedUpload = (options = {}) => {
     const resume = react.useCallback(async (params) => {
         const { uploadId, file } = params;
         // Validate connection
-        if (connectionState?.status !== "authenticated" &&
-            connectionState?.status !== "unauthenticated") {
+        if (connectionState?.status !== "authenticated") {
             const error = "Not connected to server";
             updateProgress({ status: "error", error });
             onError?.(error);
@@ -5858,8 +6133,7 @@ const useChunkedDownload = (options = {}) => {
     const download = react.useCallback((params) => {
         const { documentId, mimeType = "application/octet-stream", filename } = params;
         // Validate connection
-        if (connectionState?.status !== "authenticated" &&
-            connectionState?.status !== "unauthenticated") {
+        if (connectionState?.status !== "authenticated") {
             const error = "Not connected to server";
             updateProgress({ status: "error", error });
             onError?.(error);
@@ -5984,8 +6258,7 @@ const useDocumentMetadata = (options = {}) => {
     const { documentId, enabled } = options;
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const query = reactQuery.useQuery({
         queryKey: ["document-metadata", documentId],
         enabled: isSocketReady && !!documentId && (enabled !== false),
@@ -6010,8 +6283,7 @@ const useDocumentsMetadata = (documentIds = []) => {
     const socket = reactProvider.useSocket();
     const connectionState = reactProvider.useConnectionState();
     const queryClient = reactQuery.useQueryClient();
-    const isSocketReady = connectionState?.status === "authenticated" ||
-        connectionState?.status === "unauthenticated";
+    const isSocketReady = connectionState?.status === "authenticated";
     const query = reactQuery.useQuery({
         queryKey: ["documents-metadata", documentIds],
         enabled: isSocketReady && documentIds.length > 0,
@@ -6125,6 +6397,10 @@ Object.defineProperty(exports, "TG", {
     enumerable: true,
     get: function () { return client.TG; }
 });
+Object.defineProperty(exports, "TG_CONCEPT", {
+    enumerable: true,
+    get: function () { return client.TG_CONCEPT; }
+});
 Object.defineProperty(exports, "TG_CONTENT", {
     enumerable: true,
     get: function () { return client.TG_CONTENT; }
@@ -6145,14 +6421,14 @@ Object.defineProperty(exports, "TG_QUERY", {
     enumerable: true,
     get: function () { return client.TG_QUERY; }
 });
-Object.defineProperty(exports, "TG_REASONING", {
-    enumerable: true,
-    get: function () { return client.TG_REASONING; }
-});
 Object.defineProperty(exports, "TG_REIFIES", {
     enumerable: true,
     get: function () { return client.TG_REIFIES; }
 });
+Object.defineProperty(exports, "TG_SCORE", {
+    enumerable: true,
+    get: function () { return client.TG_SCORE; }
+});
 Object.defineProperty(exports, "TG_SELECTED_EDGE", {
     enumerable: true,
     get: function () { return client.TG_SELECTED_EDGE; }
@@ -6161,6 +6437,7 @@ exports.DEFAULT_SETTINGS = DEFAULT_SETTINGS;
 exports.NotificationProvider = NotificationProvider;
 exports.RDFS_LABEL = RDFS_LABEL;
 exports.SETTINGS_STORAGE_KEY = SETTINGS_STORAGE_KEY;
+exports.configureAuthApi = configureAuthApi;
 exports.createDocId = createDocId;
 exports.extractQuotedTriple = extractQuotedTriple;
 exports.fileToBase64 = fileToBase64;
@@ -6180,6 +6457,9 @@ exports.prepareMetadata = prepareMetadata;
 exports.textToBase64 = textToBase64;
 exports.useActivity = useActivity;
 exports.useAgentTools = useAgentTools;
+exports.useAuth = useAuth;
+exports.useAuthStore = useAuthStore;
+exports.useBootstrapStatus = useBootstrapStatus;
 exports.useChat = useChat;
 exports.useChatSession = useChatSession;
 exports.useChunkedDownload = useChunkedDownload;
@@ -6203,6 +6483,8 @@ exports.useKnowledgeCores = useKnowledgeCores;
 exports.useLLMModels = useLLMModels;
 exports.useLibrary = useLibrary;
 exports.useLoadStateStore = useLoadStateStore;
+exports.useLogin = useLogin;
+exports.useLogout = useLogout;
 exports.useMcpTools = useMcpTools;
 exports.useNlpQuery = useNlpQuery;
 exports.useNodeDetails = useNodeDetails;
@@ -6223,6 +6505,11 @@ exports.useStructuredQuery = useStructuredQuery;
 exports.useTokenCosts = useTokenCosts;
 exports.useTriples = useTriples;
 exports.useVectorSearch = useVectorSearch;
+exports.useWhoami = useWhoami;
 exports.useWorkbenchStateStore = useWorkbenchStateStore;
+exports.useWorkspace = useWorkspace;
+exports.useWorkspaceStore = useWorkspaceStore;
+exports.useWorkspaceSync = useWorkspaceSync;
+exports.useWorkspaces = useWorkspaces;
 exports.vectorSearch = vectorSearch;
 //# sourceMappingURL=index.cjs.map