@manta-eu/react 0.1.9 → 0.1.10

package/src/providers/ChatManagerProvider.tsx

@@ -0,0 +1,464 @@
+import { buildPlanHref } from "@manta-eu/client/shared/agent-mode";
+import { ChatContextKind, type ChatContext } from "@manta-eu/client/shared/agent-types";
+import {
+  chatIdSchema,
+  chatManagerBasePath,
+  type ChatManagerClient,
+  type ConversationSummary,
+  type DeleteConversationResult,
+  type ListConversationsInput,
+} from "@manta-eu/client/shared/chat-manager";
+import { datastoreSocketQuery } from "@manta-eu/client/shared/datastore-path";
+import { chatIdToPath, newChatPath, type ChatUIMessage } from "@manta-eu/client/shared/index";
+import { useAgent } from "agents/react";
+import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { matchPath, useLocation, useMatch, useNavigate } from "react-router";
+import { toast } from "sonner";
+import { match } from "ts-pattern";
+import { ChatManagerContext, type ChatManagerContextValue, type MessageHandoff } from "./chat-connection-context";
+import {
+  createBlankConversationLifecycle,
+  mapManagerConnectionState,
+  type BlankConversationLifecycle,
+} from "./chat-connection-lifecycle";
+import { useChatSocketAuth } from "./chat-socket-auth";
+import { useMantaClient } from "./index";
+
+export { useChatManagerConnection, type ChatManagerConnectionContextValue } from "./chat-connection-context";
+
+export type ChatManagerProviderProps = {
+  onSelectPlan?: (planIri: string) => void;
+  datastoreId: string | undefined;
+  children: ReactNode;
+};
+
+type ContextTransition =
+  | { kind: "select"; context: ChatContext }
+  | { kind: "start"; context: ChatContext; message: ChatUIMessage }
+  | { kind: "reassign"; context: ChatContext; source: ConversationSummary };
+
+type ConversationSelection =
+  | { kind: "active"; conversation: ConversationSummary }
+  | { kind: "pending-context"; context: ChatContext };
+
+type ExpectedConversationClose = {
+  conversationId: string;
+};
+
+function activeConversationFromSelection(selection: ConversationSelection | undefined) {
+  return selection?.kind === "active" ? selection.conversation : undefined;
+}
+
+function clearExpectedConversationClose(
+  ref: { current: ExpectedConversationClose | undefined },
+  expectedClose: ExpectedConversationClose | undefined,
+) {
+  if (ref.current === expectedClose) ref.current = undefined;
+}
+
+export function ChatManagerProvider(props: ChatManagerProviderProps) {
+  const { onSelectPlan, datastoreId, children } = props;
+  const { mantaBaseUrl } = useMantaClient();
+  const datastoreQuery = useMemo(() => datastoreSocketQuery(datastoreId), [datastoreId]);
+  const navigate = useNavigate();
+  const location = useLocation();
+  const chatMatch = useMatch("/chat/:chatId");
+  const parsedRoutedConversationId = chatIdSchema.safeParse(chatMatch?.params.chatId);
+  const routedConversationId = parsedRoutedConversationId.success ? parsedRoutedConversationId.data : undefined;
+  const onNewChatPath = matchPath(newChatPath, location.pathname) !== null;
+  const invalidConversationRoute =
+    matchPath("/chat/*", location.pathname) !== null && !onNewChatPath && !routedConversationId;
+
+  const [conversationSelection, setConversationSelection] = useState<ConversationSelection>();
+  const [messageHandoff, setMessageHandoff] = useState<MessageHandoff>();
+  const activeConversation = activeConversationFromSelection(conversationSelection);
+  const pendingContext = conversationSelection?.kind === "pending-context" ? conversationSelection.context : undefined;
+  const transitionRevisionRef = useRef(0);
+  const blankConversationRef = useRef<BlankConversationLifecycle>(createBlankConversationLifecycle());
+  const expectedClosedConversationRef = useRef<ExpectedConversationClose | undefined>(undefined);
+  const preserveBlankLifecycleOnNextBlankChatRef = useRef(false);
+  const conversationSelectionRef = useRef(conversationSelection);
+  const pathnameRef = useRef(location.pathname);
+  const routedConversationIdRef = useRef(routedConversationId);
+
+  // Where navigate() was last sent, which react-router's deferred location has not reached yet.
+  const requestedPathRef = useRef(location.pathname);
+  conversationSelectionRef.current = conversationSelection;
+
+  // Any move we did not request ourselves (back button, a redirect elsewhere) settles the target.
+  if (pathnameRef.current !== location.pathname) requestedPathRef.current = location.pathname;
+  pathnameRef.current = location.pathname;
+  routedConversationIdRef.current = routedConversationId;
+
+  const socketAuth = useChatSocketAuth(datastoreQuery);
+  const managerAgent = useAgent<ChatManagerClient, ChatManagerClient["state"]>({
+    agent: "ChatManager",
+    basePath: chatManagerBasePath,
+    host: mantaBaseUrl.host,
+    query: socketAuth.query,
+    ...("cacheTtl" in socketAuth ? { cacheTtl: socketAuth.cacheTtl } : {}),
+  });
+
+  const listConversations = useCallback(
+    (input: ListConversationsInput = {}): Promise<ConversationSummary[]> => managerAgent.stub.listConversations(input),
+    [managerAgent],
+  );
+
+  const deleteConversation = useCallback(
+    async (id: string): Promise<DeleteConversationResult> => {
+      const conversationId = chatIdSchema.parse(id);
+      const deletingInitiallyActiveConversation =
+        activeConversationFromSelection(conversationSelectionRef.current)?.id === conversationId;
+      const expectedClose = deletingInitiallyActiveConversation ? { conversationId } : undefined;
+      if (expectedClose) expectedClosedConversationRef.current = expectedClose;
+
+      try {
+        const result = await managerAgent.stub.deleteConversation({ id: conversationId });
+        if (result.status !== "deleted") {
+          clearExpectedConversationClose(expectedClosedConversationRef, expectedClose);
+          return result;
+        }
+
+        const currentRoutedConversationId = routedConversationIdRef.current;
+        const deletingRoutedConversation = currentRoutedConversationId === conversationId;
+        const deletingActiveConversation =
+          !currentRoutedConversationId &&
+          activeConversationFromSelection(conversationSelectionRef.current)?.id === conversationId;
+
+        if (deletingRoutedConversation) {
+          transitionRevisionRef.current++;
+          void navigate(newChatPath, { replace: true });
+        } else if (deletingActiveConversation) {
+          transitionRevisionRef.current++;
+          setMessageHandoff(undefined);
+          setConversationSelection(undefined);
+        }
+
+        return result;
+      } catch (error) {
+        clearExpectedConversationClose(expectedClosedConversationRef, expectedClose);
+        throw error;
+      }
+    },
+    [managerAgent, navigate],
+  );
+
+  const openConversation = useCallback(
+    (id: string) => {
+      const conversationId = chatIdSchema.parse(id);
+      const path = chatIdToPath(conversationId);
+
+      // The pending target: a transition may not have committed, and window.location is the host's URL here.
+      if (requestedPathRef.current === path) return;
+
+      requestedPathRef.current = path;
+
+      transitionRevisionRef.current++;
+      setMessageHandoff(undefined);
+      setConversationSelection((current) => (current?.kind === "pending-context" ? undefined : current));
+      void navigate(path);
+    },
+    [navigate],
+  );
+
+  const sendBlankConversationMessage = useCallback(
+    (message: ChatUIMessage): Promise<void> => {
+      const lifecycle = blankConversationRef.current;
+      if (lifecycle.materialization || lifecycle.conversationId) {
+        return Promise.reject(new Error("A new chat is already starting."));
+      }
+
+      setMessageHandoff({ message });
+      function clearMessageHandoff() {
+        setMessageHandoff((current) => (current?.message.id === message.id ? undefined : current));
+      }
+
+      const revision = transitionRevisionRef.current;
+      const pathname = pathnameRef.current;
+      function isCurrentLifecycle() {
+        return (
+          blankConversationRef.current === lifecycle &&
+          transitionRevisionRef.current === revision &&
+          pathnameRef.current === pathname
+        );
+      }
+      const materialization = (async () => {
+        try {
+          const conversation = await managerAgent.stub.createConversation({
+            idempotencyKey: lifecycle.idempotencyKey,
+          });
+
+          if (!isCurrentLifecycle()) {
+            clearMessageHandoff();
+            await managerAgent.stub.deleteConversation({ id: conversation.id });
+            return;
+          }
+
+          lifecycle.conversationId = conversation.id;
+          setMessageHandoff({ conversationId: conversation.id, message });
+          setConversationSelection({ kind: "active", conversation });
+          transitionRevisionRef.current++;
+          void navigate(chatIdToPath(conversation.id), { replace: true });
+        } catch (error) {
+          if (!isCurrentLifecycle()) {
+            clearMessageHandoff();
+            return;
+          }
+
+          clearMessageHandoff();
+          toast.error("Couldn't start a new chat. Please try again.");
+          throw error;
+        } finally {
+          lifecycle.materialization = undefined;
+        }
+      })();
+
+      lifecycle.materialization = materialization;
+      return materialization;
+    },
+    [managerAgent, navigate],
+  );
+
+  const startNewChat = useCallback(() => {
+    transitionRevisionRef.current++;
+    blankConversationRef.current = createBlankConversationLifecycle();
+    setMessageHandoff(undefined);
+    setConversationSelection(undefined);
+
+    if (!onNewChatPath) {
+      preserveBlankLifecycleOnNextBlankChatRef.current = true;
+      void navigate(newChatPath);
+    }
+  }, [onNewChatPath, navigate]);
+
+  // `/` is still a blank chat in an app that gives its datastores no home page.
+  useEffect(() => {
+    if (onNewChatPath || location.pathname === "/") {
+      const preserveBlankLifecycle = preserveBlankLifecycleOnNextBlankChatRef.current;
+      if (!preserveBlankLifecycle) {
+        blankConversationRef.current = createBlankConversationLifecycle();
+        transitionRevisionRef.current++;
+      }
+      preserveBlankLifecycleOnNextBlankChatRef.current = false;
+      setMessageHandoff(undefined);
+      setConversationSelection(undefined);
+    } else {
+      preserveBlankLifecycleOnNextBlankChatRef.current = false;
+    }
+  }, [location.pathname, onNewChatPath]);
+
+  useEffect(() => {
+    const expectedClose = expectedClosedConversationRef.current;
+    if (expectedClose && expectedClose.conversationId !== activeConversation?.id) {
+      expectedClosedConversationRef.current = undefined;
+    }
+  }, [activeConversation?.id]);
+
+  useEffect(() => {
+    if (managerAgent.readyState !== WebSocket.OPEN) return;
+
+    if (invalidConversationRoute) {
+      transitionRevisionRef.current++;
+      setConversationSelection((current) => (current?.kind === "active" ? undefined : current));
+      toast.error("Chat not found.");
+      void navigate(newChatPath, { replace: true });
+      return;
+    }
+
+    if (
+      !routedConversationId ||
+      routedConversationId === activeConversationFromSelection(conversationSelectionRef.current)?.id
+    ) {
+      return;
+    }
+
+    const revision = ++transitionRevisionRef.current;
+    setMessageHandoff((current) => (current?.conversationId === routedConversationId ? current : undefined));
+    setConversationSelection(undefined);
+
+    void managerAgent.stub
+      .getConversation({ id: routedConversationId })
+      .then((conversation) => {
+        if (transitionRevisionRef.current !== revision) return;
+        if (conversation) {
+          setConversationSelection({ kind: "active", conversation });
+          return;
+        }
+
+        toast.error("Chat not found.");
+        void navigate(newChatPath, { replace: true });
+      })
+      .catch(() => {
+        if (transitionRevisionRef.current !== revision) return;
+        toast.error("Couldn't open the chat. Please try again.");
+        void navigate(newChatPath, { replace: true });
+      });
+  }, [invalidConversationRoute, managerAgent, managerAgent.readyState, navigate, routedConversationId]);
+
+  const transitionContext = useCallback(
+    async (transition: ContextTransition): Promise<ConversationSummary | undefined> => {
+      const revision = ++transitionRevisionRef.current;
+      const pathname = pathnameRef.current;
+      const source = transition.kind === "reassign" ? transition.source : undefined;
+      const initialMessage = transition.kind === "start" ? transition.message : undefined;
+
+      if (initialMessage) setMessageHandoff({ message: initialMessage });
+
+      function clearInitialMessage() {
+        if (!initialMessage) return;
+        setMessageHandoff((current) => (current?.message.id === initialMessage.id ? undefined : current));
+      }
+
+      let conversation: ConversationSummary | null;
+      try {
+        conversation = await match(transition)
+          .with({ kind: "select" }, ({ context }) => managerAgent.stub.findContextConversation({ context }))
+          .with({ kind: "start" }, ({ context }) => managerAgent.stub.ensureContextConversation({ context }))
+          .with({ kind: "reassign" }, ({ context, source }) =>
+            managerAgent.stub.reassignConversationContext({ context, conversationId: source.id }),
+          )
+          .exhaustive();
+      } catch (error) {
+        clearInitialMessage();
+        if (transitionRevisionRef.current !== revision || pathnameRef.current !== pathname) return undefined;
+        throw error;
+      }
+
+      if (transitionRevisionRef.current !== revision || pathnameRef.current !== pathname) {
+        clearInitialMessage();
+        if (source && conversation) {
+          setConversationSelection((current) =>
+            current?.kind === "active" && current.conversation.id === source.id
+              ? { kind: "active", conversation }
+              : current,
+          );
+        }
+        return undefined;
+      }
+
+      if (!conversation) {
+        setMessageHandoff(undefined);
+        setConversationSelection({ kind: "pending-context", context: transition.context });
+        return undefined;
+      }
+
+      setMessageHandoff(initialMessage ? { conversationId: conversation.id, message: initialMessage } : undefined);
+      setConversationSelection({ kind: "active", conversation });
+
+      return conversation;
+    },
+    [managerAgent],
+  );
+
+  const selectContext = useCallback(
+    (context: ChatContext): Promise<void> => transitionContext({ kind: "select", context }).then(() => undefined),
+    [transitionContext],
+  );
+
+  const startContextConversation = useCallback(
+    (context: ChatContext, message: ChatUIMessage): Promise<ConversationSummary | undefined> =>
+      transitionContext({ kind: "start", context, message }),
+    [transitionContext],
+  );
+
+  const reassignCurrentConversation = useCallback(
+    (context: ChatContext): Promise<ConversationSummary | undefined> => {
+      const source = activeConversationFromSelection(conversationSelectionRef.current);
+      if (!source) return Promise.resolve(undefined);
+
+      return transitionContext({ kind: "reassign", context, source });
+    },
+    [transitionContext],
+  );
+
+  const sendNewConversationMessage = useCallback(
+    (message: ChatUIMessage): Promise<void> => {
+      const selection = conversationSelectionRef.current;
+      if (selection?.kind !== "pending-context") return sendBlankConversationMessage(message);
+
+      return startContextConversation(selection.context, message).then(() => undefined);
+    },
+    [sendBlankConversationMessage, startContextConversation],
+  );
+
+  const handleSelectPlan = useCallback(
+    async (planIri: string): Promise<void> => {
+      if (onSelectPlan) {
+        onSelectPlan(planIri);
+        return;
+      }
+
+      const context = { kind: ChatContextKind.Plan, planGraphIri: planIri } as const;
+      const source = activeConversationFromSelection(conversationSelectionRef.current);
+      if (source) {
+        try {
+          const transitioned = await reassignCurrentConversation(context);
+          if (!transitioned) return;
+        } catch {
+          toast.error("Couldn't move this chat to the plan. Please try again.");
+          return;
+        }
+      }
+
+      void navigate(buildPlanHref(planIri), { state: { fromChat: true } });
+    },
+    [navigate, onSelectPlan, reassignCurrentConversation],
+  );
+
+  const managerConnectionState = mapManagerConnectionState(managerAgent);
+  const selectedContext = activeConversation?.context ?? pendingContext;
+  const isConversationLoading = routedConversationId !== undefined && activeConversation?.id !== routedConversationId;
+  const context = useMemo<ChatManagerContextValue>(
+    () => ({
+      managerConnection: {
+        agent: managerAgent,
+        activeConversation,
+        managerState: managerAgent.state,
+        selectedContext,
+        pendingMessage: messageHandoff?.message,
+        isConversationLoading,
+        connectionState: managerConnectionState,
+        listConversations,
+        deleteConversation,
+        openConversation,
+        sendNewConversationMessage,
+        startNewChat,
+        selectContext,
+        startContextConversation,
+        reassignCurrentConversation,
+        handleSelectPlan,
+      },
+      session: {
+        activeConversationId: activeConversation?.id,
+        host: mantaBaseUrl.host,
+        datastoreQuery,
+        messageHandoff,
+        consumeMessageHandoff: (messageId) => {
+          setMessageHandoff((current) => (current?.message.id === messageId ? undefined : current));
+        },
+      },
+    }),
+    [
+      activeConversation,
+      deleteConversation,
+      handleSelectPlan,
+      isConversationLoading,
+      listConversations,
+      managerAgent,
+      managerAgent.state,
+      managerConnectionState,
+      mantaBaseUrl.host,
+      datastoreQuery,
+      messageHandoff,
+      openConversation,
+      reassignCurrentConversation,
+      selectContext,
+      selectedContext,
+      sendNewConversationMessage,
+      startContextConversation,
+      startNewChat,
+    ],
+  );
+
+  return <ChatManagerContext.Provider value={context}>{children}</ChatManagerContext.Provider>;
+}

package/src/providers/ChatPanelContext.tsx

@@ -0,0 +1,40 @@
+import { createContext, useCallback, useContext, useMemo, useState, type ReactNode } from "react";
+
+export type ChatPanelContextValue = {
+  chatOpen: boolean;
+  toggle: () => void;
+  open: () => void;
+  close: () => void;
+};
+
+const ChatPanelContext = createContext<ChatPanelContextValue | null>(null);
+
+export type ChatPanelProviderProps = {
+  children: ReactNode;
+};
+
+export function ChatPanelProvider(props: ChatPanelProviderProps) {
+  const { children } = props;
+
+  const [chatOpen, setChatOpen] = useState(false);
+
+  const toggle = useCallback(() => setChatOpen((value) => !value), []);
+  const open = useCallback(() => setChatOpen(true), []);
+  const close = useCallback(() => setChatOpen(false), []);
+
+  const value = useMemo(() => ({ chatOpen, toggle, open, close }), [chatOpen, toggle, open, close]);
+
+  return <ChatPanelContext.Provider value={value}>{children}</ChatPanelContext.Provider>;
+}
+
+export function useChatPanel(): ChatPanelContextValue {
+  const ctx = useContext(ChatPanelContext);
+  if (!ctx) {
+    throw new Error("useChatPanel must be used within ChatPanelProvider");
+  }
+  return ctx;
+}
+
+export function useOptionalChatPanel(): ChatPanelContextValue | null {
+  return useContext(ChatPanelContext);
+}

package/src/providers/GenerateStructuredDataProvider.tsx

@@ -0,0 +1,104 @@
+import type { JSONSchema7 } from "json-schema";
+import type { Dispatch, ReactNode, SetStateAction } from "react";
+import { createContext, use, useCallback, useEffect, useState } from "react";
+import { GenerateStructuredDataPrompt } from "../components/ai-elements/generate-structured-data-prompt";
+import { useGenerateStructuredDataMutation } from "../lib/structured-data/index";
+import { useMantaClient } from "./MantaClientProvider";
+
+export type GenerateStructuredDataProviderProps = {
+  children: ReactNode;
+};
+
+export type Data = Record<string, unknown>;
+
+export type Schema = {
+  title?: string;
+  action?: string;
+  schema: JSONSchema7;
+  onSuccess: (data: Data) => void;
+  onError?: (error: string) => void;
+};
+
+export type GenerateStructuredDataState = {
+  setSchema: Dispatch<SetStateAction<Schema | undefined>>;
+  isPending: boolean;
+};
+
+const GenerateStructuredDataProviderContext = createContext<GenerateStructuredDataState | undefined>(undefined);
+
+function isData(data: unknown): data is Data {
+  return typeof data === "object" && data !== null;
+}
+
+export function GenerateStructuredDataProvider(props: GenerateStructuredDataProviderProps) {
+  const { children } = props;
+
+  const { mantaClient } = useMantaClient();
+  const [isModalOpen, setModalOpen] = useState(false);
+  const [schema, setSchema] = useState<Schema>();
+  const generateStructuredData = useGenerateStructuredDataMutation(mantaClient);
+
+  useEffect(() => setModalOpen(!!schema), [schema]);
+
+  const onSubmit = useCallback(
+    async (prompt: string) => {
+      if (!schema) return;
+
+      setModalOpen(false);
+
+      try {
+        const response = await generateStructuredData.mutateAsync({
+          input: {
+            prompt,
+            schema: schema.schema as Record<string, unknown>,
+          },
+        });
+
+        const { data, error } = response.generateStructuredData;
+
+        if (error) {
+          schema.onError?.(error);
+          return;
+        }
+
+        if (isData(data)) {
+          schema.onSuccess(data);
+        } else {
+          schema.onError?.("Could not parse the response");
+        }
+      } finally {
+        setSchema(undefined);
+      }
+    },
+    [schema],
+  );
+
+  const value: GenerateStructuredDataState = {
+    setSchema,
+    isPending: generateStructuredData.isPending,
+  };
+
+  return (
+    <GenerateStructuredDataProviderContext.Provider value={value}>
+      {children}
+
+      <GenerateStructuredDataPrompt
+        open={isModalOpen}
+        title={schema?.title}
+        action={schema?.action}
+        onClose={() => setModalOpen(false)}
+        onSubmit={onSubmit}
+      />
+    </GenerateStructuredDataProviderContext.Provider>
+  );
+}
+
+export function useMantaGenerateStructuredData(): GenerateStructuredDataState {
+  const context = use(GenerateStructuredDataProviderContext);
+
+  if (!context) {
+    throw new Error("useMantaGenerateStructuredData must be used within a GenerateStructuredDataProvider");
+  }
+
+  return context;
+}

package/src/providers/InstanceLabelsProvider.tsx

@@ -0,0 +1,33 @@
+import type { ReactNode } from "react";
+import { useMemo } from "react";
+import { useResolvedTermsState } from "../hooks/resolved-terms";
+import { InstanceLabelsContext } from "../hooks/use-instance-labels";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "../hooks/use-sparql-options";
+import { bindingsToInstanceLabels, buildInstanceLabelsQuery } from "../lib/instance-labels";
+import { collectBindings } from "../lib/rdf-helpers";
+
+export type InstanceLabelsProviderProps = {
+  children: ReactNode;
+};
+
+export function InstanceLabelsProvider(props: InstanceLabelsProviderProps) {
+  const { children } = props;
+
+  const engine = useSparqlEngine();
+  const options = useSparqlOptions();
+
+  const loadTerms = useMemo(
+    () =>
+      async (iris: string[]): Promise<Map<string, string | null>> => {
+        const stream = await engine.queryBindings(buildInstanceLabelsQuery(iris), optionsToContext(options));
+        const labels = bindingsToInstanceLabels(await collectBindings(stream));
+
+        return new Map(iris.map((iri) => [iri, labels.get(iri) ?? null]));
+      },
+    [engine, options],
+  );
+
+  const value = useResolvedTermsState(loadTerms, null);
+
+  return <InstanceLabelsContext.Provider value={value}>{children}</InstanceLabelsContext.Provider>;
+}

package/src/providers/KnowledgeGraphPollingProvider.tsx

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+import { createContext, use } from "react";
+
+export const defaultKnowledgeGraphPollIntervalMs = 3000;
+
+const KnowledgeGraphPollingContext = createContext(defaultKnowledgeGraphPollIntervalMs);
+
+export type KnowledgeGraphPollingProviderProps = {
+  intervalMs?: number;
+  children: ReactNode;
+};
+
+export function KnowledgeGraphPollingProvider(props: KnowledgeGraphPollingProviderProps) {
+  const { intervalMs, children } = props;
+
+  return (
+    <KnowledgeGraphPollingContext.Provider value={intervalMs ?? defaultKnowledgeGraphPollIntervalMs}>
+      {children}
+    </KnowledgeGraphPollingContext.Provider>
+  );
+}
+
+export function useKnowledgeGraphPollInterval() {
+  return use(KnowledgeGraphPollingContext);
+}

package/src/providers/KnowledgeGraphStateContext.ts

@@ -0,0 +1,23 @@
+import type { GQLKnowledgeGraphState } from "@manta-eu/client";
+import { createContext, use } from "react";
+import type { KnowledgeGraphAvailability } from "./knowledge-graph-availability";
+
+export const KnowledgeGraphStateContext = createContext<KnowledgeGraphStateContextValue | undefined>(undefined);
+
+export type KnowledgeGraphStateContextValue = {
+  knowledgeGraphState: GQLKnowledgeGraphState | null;
+  knowledgeGraphAvailability: KnowledgeGraphAvailability | null;
+  isKnowledgeGraphUnavailable: boolean;
+  isLoading: boolean;
+  error: Error | null;
+};
+
+export function useKnowledgeGraphState(): KnowledgeGraphStateContextValue {
+  const context = use(KnowledgeGraphStateContext);
+
+  if (!context) {
+    throw new Error("useKnowledgeGraphState must be used within a KnowledgeGraphStateProvider");
+  }
+
+  return context;
+}