@trustgraph/react-state 1.7.3 → 2.1.0

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
@@ -510,6 +368,453 @@ const useSettings = () => {
     };
 };
 
+// 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 result = await getAuthApi().login(username, password, default_workspace);
+            setToken(result.jwt, result.jwtExpires);
+            return true;
+        }
+        catch (e) {
+            const message = e instanceof client.AuthError
+                ? e.message
+                : e instanceof Error
+                    ? e.message
+                    : "login failed";
+            setStatus("auth-failed", message);
+            return false;
+        }
+    }, [setToken, setStatus]);
+    return {
+        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
  * Provides functionality for fetching, deleting, and creating flows
@@ -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,
     };
 };
@@ -1926,7 +2207,7 @@ const useExplainabilityStore = zustand.create()((set, get) => ({
 const TG_ACTION = client.TG + "action";
 const TG_ARGUMENTS = client.TG + "arguments";
 const TG_SUBAGENT_GOAL = client.TG + "subagentGoal";
-const TG_CONCEPT = client.TG + "concept";
+const TG_CONCEPT = client.TG_CONCEPT;
 const TG_ENTITY = client.TG + "entity";
 // RDF type URIs
 const TG_AGENT_QUESTION = client.TG + "AgentQuestion";
@@ -2034,20 +2315,41 @@ function extractCommonFields(triples) {
     return { label, derivedFrom };
 }
 /**
- * Extract inline edges from triples (tg:edge quoted triples).
+ * 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 edges = [];
+    const bySubject = new Map();
     for (const t of triples) {
-        if (getTermValue$1(t.p) === client.TG_EDGE && t.o.t === "t" && t.o.tr) {
+        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) {
-                edges.push({ 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 edges;
+    return Array.from(bySubject.values()).filter(se => se.edge.s !== "");
 }
 // ── Parsers ─────────────────────────────────────────────────────────
 function parseQuestionTriples(explainId, explainGraph, triples) {
@@ -2111,15 +2413,21 @@ function parseSynthesisTriples(explainId, explainGraph, triples) {
 }
 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)
             edge = extractQuotedTriple(triple.o);
-        else if (p === client.TG_REASONING)
-            reasoning = getTermValue$1(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);
+        }
     }
-    return { edge, reasoning };
+    return { edge, concept, score };
 }
 function parseGroundingTriples(explainId, explainGraph, triples) {
     const { label, derivedFrom } = extractCommonFields(triples);
@@ -2250,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
@@ -2437,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([
@@ -2922,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, }) => {
@@ -2979,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) {
@@ -3020,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) {
@@ -3067,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, }) => {
@@ -3117,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
@@ -3176,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
@@ -3281,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, }) => {
@@ -3332,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
@@ -3376,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({
@@ -3539,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({
@@ -3699,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({
@@ -3720,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) => ({
@@ -3747,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]]);
                 });
@@ -3820,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) => {
@@ -3868,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) => {
@@ -3961,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,
@@ -4092,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,
@@ -4231,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
@@ -4334,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
@@ -4466,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"],
@@ -4553,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
@@ -4827,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
      */
@@ -5457,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;
 /**
@@ -5575,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);
@@ -5667,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);
@@ -5887,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);
@@ -6013,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),
@@ -6039,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,
@@ -6154,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; }
@@ -6174,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; }
@@ -6190,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;
@@ -6209,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;
@@ -6232,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;
@@ -6252,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