@elqnt/kg 3.0.0 → 3.0.2

package/dist/chunk-ZEPJC46Z.mjs

@@ -0,0 +1,1031 @@
+"use client";
+import {
+  cancelCrawlJobApi,
+  cancelFullIngestExtractionApi,
+  createDesignerEdgeApi,
+  createDesignerNodeApi,
+  createGraphApi,
+  deleteDesignerEdgeApi,
+  deleteDesignerNodeApi,
+  deleteGraphApi,
+  getCrawlJobStatusApi,
+  getCrawledPagesApi,
+  getDesignerNodeApi,
+  getGraphApi,
+  getGraphLabelsApi,
+  getKGNodeApi,
+  ingestFullIngestNodesApi,
+  ingestKGNodeApi,
+  listCrawlJobsApi,
+  listDesignerEdgesApi,
+  listDesignerNodesApi,
+  listGraphsApi,
+  queryGraphApi,
+  startCrawlJobApi,
+  startFullIngestExtractionApi,
+  startQuickIngestApi,
+  updateDesignerEdgeApi,
+  updateDesignerNodeApi,
+  updateGraphApi,
+  updateKGNodeApi
+} from "./chunk-5D7RJC7D.mjs";
+import {
+  createFullIngestTransport
+} from "./chunk-MAEB7UOW.mjs";
+
+// hooks/use-graphs.ts
+import { useCallback, useMemo } from "react";
+import { useApiAsync } from "@elqnt/api-client/hooks";
+
+// hooks/use-options-ref.ts
+import { useRef, useEffect } from "react";
+function useOptionsRef(options) {
+  const ref = useRef(options);
+  useEffect(() => {
+    ref.current = options;
+  }, [options]);
+  return ref;
+}
+
+// hooks/use-graphs.ts
+function useGraphs(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listGraphs,
+    loading: listLoading,
+    error: listError
+  } = useApiAsync(
+    () => listGraphsApi(optionsRef.current),
+    (data) => data.graphs || [],
+    []
+  );
+  const {
+    execute: getGraphInternal,
+    loading: getLoading,
+    error: getError
+  } = useApiAsync(
+    (graphId) => getGraphApi(graphId, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const getGraph = useCallback((graphId) => getGraphInternal(graphId), [getGraphInternal]);
+  const {
+    execute: createGraphInternal,
+    loading: createLoading,
+    error: createError
+  } = useApiAsync(
+    (graph) => createGraphApi(graph, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const createGraph = useCallback(
+    (graph) => createGraphInternal(graph),
+    [createGraphInternal]
+  );
+  const {
+    execute: updateGraphInternal,
+    loading: updateLoading,
+    error: updateError
+  } = useApiAsync(
+    (graphId, updates) => updateGraphApi(graphId, updates, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const updateGraph = useCallback(
+    (graphId, updates) => updateGraphInternal(graphId, updates),
+    [updateGraphInternal]
+  );
+  const {
+    execute: deleteGraphInternal,
+    loading: deleteLoading,
+    error: deleteError
+  } = useApiAsync(
+    (graphId) => deleteGraphApi(graphId, optionsRef.current),
+    (data) => data.success ?? true,
+    false
+  );
+  const deleteGraph = useCallback(
+    (graphId) => deleteGraphInternal(graphId),
+    [deleteGraphInternal]
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading;
+  const error = listError || getError || createError || updateError || deleteError;
+  return useMemo(
+    () => ({
+      loading,
+      error,
+      listGraphs,
+      getGraph,
+      createGraph,
+      updateGraph,
+      deleteGraph
+    }),
+    [loading, error, listGraphs, getGraph, createGraph, updateGraph, deleteGraph]
+  );
+}
+
+// hooks/use-kg-query.ts
+import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useApiAsync as useApiAsync2 } from "@elqnt/api-client/hooks";
+function useKGQuery(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: queryInternal,
+    loading: queryLoading,
+    error: queryError
+  } = useApiAsync2(
+    (queryParams) => queryGraphApi(queryParams, optionsRef.current),
+    (data) => data,
+    null
+  );
+  const query = useCallback2(
+    (queryParams) => queryInternal(queryParams),
+    [queryInternal]
+  );
+  const {
+    execute: getLabels,
+    loading: labelsLoading,
+    error: labelsError
+  } = useApiAsync2(
+    () => getGraphLabelsApi(optionsRef.current),
+    (data) => data.labels || [],
+    []
+  );
+  const {
+    execute: getNodeInternal,
+    loading: nodeLoading,
+    error: nodeError
+  } = useApiAsync2(
+    (nodeId) => getKGNodeApi(nodeId, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const getNode = useCallback2((nodeId) => getNodeInternal(nodeId), [getNodeInternal]);
+  const {
+    execute: ingestNodeInternal,
+    loading: ingestLoading,
+    error: ingestError
+  } = useApiAsync2(
+    (node) => ingestKGNodeApi(node, optionsRef.current),
+    (data) => data.nodeId || null,
+    null
+  );
+  const ingestNode = useCallback2(
+    (node) => ingestNodeInternal(node),
+    [ingestNodeInternal]
+  );
+  const {
+    execute: updateNodeInternal,
+    loading: updateLoading,
+    error: updateError
+  } = useApiAsync2(
+    (nodeId, updates) => updateKGNodeApi(nodeId, updates, optionsRef.current),
+    (data) => data.success ?? true,
+    false
+  );
+  const updateNode = useCallback2(
+    (nodeId, updates) => updateNodeInternal(nodeId, updates),
+    [updateNodeInternal]
+  );
+  const loading = queryLoading || labelsLoading || nodeLoading || ingestLoading || updateLoading;
+  const error = queryError || labelsError || nodeError || ingestError || updateError;
+  return useMemo2(
+    () => ({
+      loading,
+      error,
+      query,
+      getLabels,
+      getNode,
+      ingestNode,
+      updateNode
+    }),
+    [loading, error, query, getLabels, getNode, ingestNode, updateNode]
+  );
+}
+
+// hooks/use-kg-designer.ts
+import { useCallback as useCallback3, useMemo as useMemo3 } from "react";
+import { useApiAsync as useApiAsync3 } from "@elqnt/api-client/hooks";
+function useKGDesigner(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listNodes,
+    loading: listNodesLoading,
+    error: listNodesError
+  } = useApiAsync3(
+    () => listDesignerNodesApi(optionsRef.current),
+    (data) => data.nodes || [],
+    []
+  );
+  const {
+    execute: getNodeInternal,
+    loading: getNodeLoading,
+    error: getNodeError
+  } = useApiAsync3(
+    (label) => getDesignerNodeApi(label, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const getNode = useCallback3((label) => getNodeInternal(label), [getNodeInternal]);
+  const {
+    execute: createNodeInternal,
+    loading: createNodeLoading,
+    error: createNodeError
+  } = useApiAsync3(
+    (node) => createDesignerNodeApi(node, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const createNode = useCallback3(
+    (node) => createNodeInternal(node),
+    [createNodeInternal]
+  );
+  const {
+    execute: updateNodeInternal,
+    loading: updateNodeLoading,
+    error: updateNodeError
+  } = useApiAsync3(
+    (label, updates) => updateDesignerNodeApi(label, updates, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const updateNode = useCallback3(
+    (label, updates) => updateNodeInternal(label, updates),
+    [updateNodeInternal]
+  );
+  const {
+    execute: deleteNodeInternal,
+    loading: deleteNodeLoading,
+    error: deleteNodeError
+  } = useApiAsync3(
+    (label) => deleteDesignerNodeApi(label, optionsRef.current),
+    (data) => data.success ?? true,
+    false
+  );
+  const deleteNode = useCallback3((label) => deleteNodeInternal(label), [deleteNodeInternal]);
+  const {
+    execute: listEdges,
+    loading: listEdgesLoading,
+    error: listEdgesError
+  } = useApiAsync3(
+    () => listDesignerEdgesApi(optionsRef.current),
+    (data) => data.edges || [],
+    []
+  );
+  const {
+    execute: createEdgeInternal,
+    loading: createEdgeLoading,
+    error: createEdgeError
+  } = useApiAsync3(
+    (edge) => createDesignerEdgeApi(edge, optionsRef.current),
+    (data) => data.edge || null,
+    null
+  );
+  const createEdge = useCallback3(
+    (edge) => createEdgeInternal(edge),
+    [createEdgeInternal]
+  );
+  const {
+    execute: updateEdgeInternal,
+    loading: updateEdgeLoading,
+    error: updateEdgeError
+  } = useApiAsync3(
+    (label, updates) => updateDesignerEdgeApi(label, updates, optionsRef.current),
+    (data) => data.edge || null,
+    null
+  );
+  const updateEdge = useCallback3(
+    (label, updates) => updateEdgeInternal(label, updates),
+    [updateEdgeInternal]
+  );
+  const {
+    execute: deleteEdgeInternal,
+    loading: deleteEdgeLoading,
+    error: deleteEdgeError
+  } = useApiAsync3(
+    (label) => deleteDesignerEdgeApi(label, optionsRef.current),
+    (data) => data.success ?? true,
+    false
+  );
+  const deleteEdge = useCallback3((label) => deleteEdgeInternal(label), [deleteEdgeInternal]);
+  const loading = listNodesLoading || getNodeLoading || createNodeLoading || updateNodeLoading || deleteNodeLoading || listEdgesLoading || createEdgeLoading || updateEdgeLoading || deleteEdgeLoading;
+  const error = listNodesError || getNodeError || createNodeError || updateNodeError || deleteNodeError || listEdgesError || createEdgeError || updateEdgeError || deleteEdgeError;
+  return useMemo3(
+    () => ({
+      loading,
+      error,
+      // Nodes
+      listNodes,
+      getNode,
+      createNode,
+      updateNode,
+      deleteNode,
+      // Edges
+      listEdges,
+      createEdge,
+      updateEdge,
+      deleteEdge
+    }),
+    [
+      loading,
+      error,
+      listNodes,
+      getNode,
+      createNode,
+      updateNode,
+      deleteNode,
+      listEdges,
+      createEdge,
+      updateEdge,
+      deleteEdge
+    ]
+  );
+}
+
+// hooks/use-crawl-jobs.ts
+import { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+import { useApiAsync as useApiAsync4 } from "@elqnt/api-client/hooks";
+function useCrawlJobs(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listJobsInternal,
+    loading: listLoading,
+    error: listError
+  } = useApiAsync4(
+    (params) => listCrawlJobsApi({ ...optionsRef.current, ...params }),
+    (data) => ({ jobs: data.jobs || [], total: data.total || 0 }),
+    { jobs: [], total: 0 }
+  );
+  const listJobs = useCallback4(
+    (params) => listJobsInternal(params),
+    [listJobsInternal]
+  );
+  const {
+    execute: startJobInternal,
+    loading: startLoading,
+    error: startError
+  } = useApiAsync4(
+    (params) => startCrawlJobApi(params, optionsRef.current),
+    (data) => data.jobId || null,
+    null
+  );
+  const startJob = useCallback4(
+    (params) => startJobInternal(params),
+    [startJobInternal]
+  );
+  const {
+    execute: getJobStatusInternal,
+    loading: statusLoading,
+    error: statusError
+  } = useApiAsync4(
+    (jobId) => getCrawlJobStatusApi(jobId, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const getJobStatus = useCallback4(
+    (jobId) => getJobStatusInternal(jobId),
+    [getJobStatusInternal]
+  );
+  const {
+    execute: cancelJobInternal,
+    loading: cancelLoading,
+    error: cancelError
+  } = useApiAsync4(
+    (jobId) => cancelCrawlJobApi(jobId, optionsRef.current),
+    (data) => data.success ?? true,
+    false
+  );
+  const cancelJob = useCallback4((jobId) => cancelJobInternal(jobId), [cancelJobInternal]);
+  const {
+    execute: getCrawledPagesInternal,
+    loading: pagesLoading,
+    error: pagesError
+  } = useApiAsync4(
+    (jobId) => getCrawledPagesApi(jobId, optionsRef.current),
+    (data) => data.pages || [],
+    []
+  );
+  const getCrawledPages = useCallback4(
+    (jobId) => getCrawledPagesInternal(jobId),
+    [getCrawledPagesInternal]
+  );
+  const loading = listLoading || startLoading || statusLoading || cancelLoading || pagesLoading;
+  const error = listError || startError || statusError || cancelError || pagesError;
+  return useMemo4(
+    () => ({
+      loading,
+      error,
+      listJobs,
+      startJob,
+      getJobStatus,
+      cancelJob,
+      getCrawledPages
+    }),
+    [loading, error, listJobs, startJob, getJobStatus, cancelJob, getCrawledPages]
+  );
+}
+
+// hooks/use-quick-ingest.ts
+import { useCallback as useCallback5, useMemo as useMemo5, useState, useRef as useRef2 } from "react";
+function useQuickIngest(options) {
+  const optionsRef = useOptionsRef(options);
+  const [items, setItems] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [error, setError] = useState(null);
+  const abortControllerRef = useRef2(null);
+  const uploadFile = useCallback5(async (file) => {
+    const tempId = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const placeholderItem = {
+      id: tempId,
+      type: "document",
+      name: file.name,
+      sizeBytes: file.size,
+      status: "uploading",
+      progress: 0
+    };
+    setItems((prev) => [...prev, placeholderItem]);
+    try {
+      const result = await optionsRef.current.onUploadFile(file);
+      if (result.error) {
+        throw new Error(result.error);
+      }
+      const uploadedItem = {
+        id: tempId,
+        type: "document",
+        name: file.name,
+        url: result.url,
+        sizeBytes: file.size,
+        pageCount: result.pageCount,
+        status: "ready",
+        progress: 100
+      };
+      setItems(
+        (prev) => prev.map((item) => item.id === tempId ? uploadedItem : item)
+      );
+      return uploadedItem;
+    } catch (err) {
+      setItems(
+        (prev) => prev.map(
+          (item) => item.id === tempId ? { ...item, status: "error", error: String(err) } : item
+        )
+      );
+      throw err;
+    }
+  }, []);
+  const addUrl = useCallback5((url) => {
+    const id = `url_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const item = {
+      id,
+      type: "url",
+      name: url,
+      url,
+      status: "ready",
+      progress: 0
+    };
+    setItems((prev) => [...prev, item]);
+  }, []);
+  const removeItem = useCallback5((id) => {
+    setItems((prev) => prev.filter((item) => item.id !== id));
+  }, []);
+  const clearQueue = useCallback5(() => {
+    setItems([]);
+    setError(null);
+  }, []);
+  const startIngestion = useCallback5(
+    async (ingestionOptions) => {
+      const readyItems = items.filter((item) => item.status === "ready" && item.url);
+      if (readyItems.length === 0) {
+        setError("No items ready for ingestion");
+        return;
+      }
+      setError(null);
+      setIsProcessing(true);
+      abortControllerRef.current = new AbortController();
+      setItems(
+        (prev) => prev.map(
+          (item) => item.status === "ready" ? { ...item, status: "processing" } : item
+        )
+      );
+      try {
+        const request = {
+          items: readyItems.map((item) => ({
+            id: item.id,
+            type: item.type,
+            name: item.name,
+            url: item.url
+          })),
+          options: ingestionOptions,
+          graphId: optionsRef.current.graphId || "default"
+        };
+        await startQuickIngestApi(request, optionsRef.current, (event) => {
+          switch (event.type) {
+            case "item_start":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, status: "processing", progress: 0 } : item
+                )
+              );
+              break;
+            case "item_progress":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, progress: event.progress || 0, progressText: event.text } : item
+                )
+              );
+              break;
+            case "item_complete":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? {
+                    ...item,
+                    status: "complete",
+                    progress: 100,
+                    result: {
+                      articlesCreated: event.articles,
+                      topicsCreated: event.topics,
+                      nodesCreated: event.nodesCreated,
+                      nodesByLabel: event.nodesByLabel
+                    }
+                  } : item
+                )
+              );
+              break;
+            case "item_error":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, status: "error", error: event.error } : item
+                )
+              );
+              break;
+            case "job_complete":
+              setIsProcessing(false);
+              break;
+            case "error":
+              setError(event.message || event.error || "Unknown error");
+              setIsProcessing(false);
+              break;
+            case "cancelled":
+              setIsProcessing(false);
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+                )
+              );
+              break;
+          }
+        });
+        setIsProcessing(false);
+      } catch (err) {
+        setError(String(err));
+        setIsProcessing(false);
+        setItems(
+          (prev) => prev.map(
+            (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+          )
+        );
+      }
+    },
+    [items]
+  );
+  const cancelIngestion = useCallback5(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setIsProcessing(false);
+    setItems(
+      (prev) => prev.map(
+        (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+      )
+    );
+  }, []);
+  return useMemo5(
+    () => ({
+      items,
+      isProcessing,
+      error,
+      uploadFile,
+      addUrl,
+      removeItem,
+      startIngestion,
+      cancelIngestion,
+      clearQueue
+    }),
+    [
+      items,
+      isProcessing,
+      error,
+      uploadFile,
+      addUrl,
+      removeItem,
+      startIngestion,
+      cancelIngestion,
+      clearQueue
+    ]
+  );
+}
+
+// hooks/use-full-ingest.ts
+import { useCallback as useCallback6, useMemo as useMemo6, useState as useState2, useEffect as useEffect2, useRef as useRef3 } from "react";
+function useFullIngest(options) {
+  const optionsRef = useOptionsRef(options);
+  const [sourceType, setSourceType] = useState2(null);
+  const [document, setDocument] = useState2(null);
+  const [crawlJob, setCrawlJob] = useState2(null);
+  const [selectedLabels, setSelectedLabels] = useState2([]);
+  const [extractedNodes, setExtractedNodes] = useState2([]);
+  const [extractedEdges, setExtractedEdges] = useState2([]);
+  const [isExtracting, setIsExtracting] = useState2(false);
+  const [extractionProgress, setExtractionProgress] = useState2(null);
+  const [isIngesting, setIsIngesting] = useState2(false);
+  const [ingestProgress, setIngestProgress] = useState2(null);
+  const [jobId, setJobId] = useState2(null);
+  const [error, setError] = useState2(null);
+  const transportRef = useRef3(null);
+  useEffect2(() => {
+    return () => {
+      if (transportRef.current) {
+        transportRef.current.disconnect();
+        transportRef.current = null;
+      }
+    };
+  }, []);
+  const uploadDocument = useCallback6(async (file) => {
+    setError(null);
+    try {
+      const { onUploadFile } = optionsRef.current;
+      if (onUploadFile) {
+        const result = await onUploadFile(file);
+        if (result.error) {
+          throw new Error(result.error);
+        }
+        setDocument({
+          url: result.url,
+          pageCount: result.pageCount || 0,
+          sizeBytes: file.size
+        });
+      } else {
+        const url = URL.createObjectURL(file);
+        setDocument({
+          url,
+          pageCount: 0,
+          sizeBytes: file.size
+        });
+      }
+      setSourceType("document");
+    } catch (err) {
+      setError(String(err));
+      throw err;
+    }
+  }, []);
+  const setDocumentUrl = useCallback6(
+    (url, pageCount, sizeBytes) => {
+      setDocument({ url, pageCount, sizeBytes });
+      setSourceType("document");
+      setError(null);
+    },
+    []
+  );
+  const startCrawl = useCallback6(
+    async (url, depth, maxPages) => {
+      setError(null);
+      try {
+        const response = await startCrawlJobApi(
+          { baseUrl: url, depth, maxPages },
+          optionsRef.current
+        );
+        if (!response.data?.jobId) {
+          throw new Error(response.error || "Failed to start crawl");
+        }
+        const pollInterval = setInterval(async () => {
+          const statusResponse = await getCrawlJobStatusApi(
+            response.data.jobId,
+            optionsRef.current
+          );
+          if (statusResponse.data?.job) {
+            setCrawlJob(statusResponse.data.job);
+            if (statusResponse.data.job.status === "completed" || statusResponse.data.job.status === "failed") {
+              clearInterval(pollInterval);
+              if (statusResponse.data.job.status === "failed") {
+                setError("Crawl job failed");
+              }
+            }
+          }
+        }, 2e3);
+        setSourceType("website");
+        setCrawlJob({
+          id: response.data.jobId,
+          baseUrl: url,
+          depth,
+          maxPages,
+          status: "pending",
+          pagesProcessed: 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (err) {
+        setError(String(err));
+        throw err;
+      }
+    },
+    []
+  );
+  const startExtraction = useCallback6(async () => {
+    if (!sourceType) {
+      setError("No source selected");
+      return;
+    }
+    if (selectedLabels.length === 0) {
+      setError("No labels selected");
+      return;
+    }
+    let sourceId;
+    if (sourceType === "document") {
+      if (!document) {
+        setError("No document uploaded");
+        return;
+      }
+      sourceId = document.url;
+    } else {
+      if (!crawlJob) {
+        setError("No crawl job");
+        return;
+      }
+      sourceId = crawlJob.id;
+    }
+    setError(null);
+    setIsExtracting(true);
+    setExtractedNodes([]);
+    setExtractedEdges([]);
+    setExtractionProgress(null);
+    try {
+      const request = {
+        sourceType,
+        sourceId,
+        labels: selectedLabels,
+        graphId: optionsRef.current.graphId || "default"
+      };
+      const response = await startFullIngestExtractionApi(request, optionsRef.current);
+      if (!response.data) {
+        throw new Error(response.error || "Failed to start extraction");
+      }
+      const newJobId = response.data.jobId;
+      setJobId(newJobId);
+      const transport = createFullIngestTransport({ debug: options.debug });
+      await transport.connect(optionsRef.current);
+      transportRef.current = transport;
+      transport.on("progress", (event) => {
+        setExtractionProgress({
+          current: event.currentPage,
+          total: event.totalPages,
+          phase: "extracting"
+        });
+      });
+      transport.on("node", (event) => {
+        const node = {
+          id: event.id,
+          label: event.label,
+          fields: event.fields
+        };
+        setExtractedNodes((prev) => [...prev, node]);
+      });
+      transport.on("consolidating", (event) => {
+        setExtractionProgress((prev) => ({
+          current: prev?.current || 0,
+          total: prev?.total || 0,
+          phase: "consolidating",
+          message: event.message
+        }));
+      });
+      transport.on("consolidated", (event) => {
+        setExtractionProgress((prev) => ({
+          current: prev?.current || 0,
+          total: prev?.total || 0,
+          phase: "consolidating",
+          message: event.message
+        }));
+      });
+      transport.on("linking", (event) => {
+        setExtractionProgress((prev) => ({
+          current: prev?.current || 0,
+          total: prev?.total || 0,
+          phase: "linking",
+          message: event.message
+        }));
+      });
+      transport.on("edge", (event) => {
+        const edge = {
+          id: event.id,
+          fromLabel: event.fromLabel,
+          fromName: event.fromName,
+          toLabel: event.toLabel,
+          toName: event.toName,
+          edgeLabel: event.edgeLabel,
+          confidence: event.confidence
+        };
+        setExtractedEdges((prev) => [...prev, edge]);
+      });
+      transport.on("linked", (event) => {
+        setExtractionProgress((prev) => ({
+          current: prev?.current || 0,
+          total: prev?.total || 0,
+          phase: "linking",
+          message: event.message
+        }));
+      });
+      transport.on("complete", (event) => {
+        setExtractionProgress((prev) => ({
+          current: prev?.current || 0,
+          total: prev?.total || 0,
+          phase: "complete",
+          message: event.message
+        }));
+        setIsExtracting(false);
+        setJobId(null);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.on("error", (event) => {
+        setError(event.message);
+        setIsExtracting(false);
+        setJobId(null);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.subscribeToJob(newJobId);
+    } catch (err) {
+      setError(String(err));
+      setIsExtracting(false);
+      setJobId(null);
+    }
+  }, [sourceType, document, crawlJob, selectedLabels, options.debug]);
+  const cancelExtraction = useCallback6(async () => {
+    if (!jobId) return;
+    try {
+      await cancelFullIngestExtractionApi(jobId, optionsRef.current);
+      if (transportRef.current) {
+        transportRef.current.disconnect();
+        transportRef.current = null;
+      }
+      setIsExtracting(false);
+      setJobId(null);
+    } catch (err) {
+      setError(String(err));
+    }
+  }, [jobId]);
+  const removeNode = useCallback6((id) => {
+    setExtractedNodes((prev) => prev.filter((node) => node.id !== id));
+  }, []);
+  const updateNode = useCallback6((id, fields) => {
+    setExtractedNodes(
+      (prev) => prev.map((node) => node.id === id ? { ...node, fields } : node)
+    );
+  }, []);
+  const removeEdge = useCallback6((id) => {
+    setExtractedEdges((prev) => prev.filter((edge) => edge.id !== id));
+  }, []);
+  const ingestNodes = useCallback6(async () => {
+    if (!jobId) {
+      setError("No job ID - extraction must be started first");
+      return;
+    }
+    if (extractedNodes.length === 0) {
+      setError("No nodes to ingest");
+      return;
+    }
+    setError(null);
+    setIsIngesting(true);
+    setIngestProgress(null);
+    try {
+      const request = {
+        jobId
+      };
+      const response = await ingestFullIngestNodesApi(request, optionsRef.current);
+      if (!response.data) {
+        throw new Error(response.error || "Failed to start ingestion");
+      }
+      const transport = createFullIngestTransport({ debug: options.debug });
+      await transport.connect(optionsRef.current);
+      transportRef.current = transport;
+      transport.on("ingest_progress", (event) => {
+        setIngestProgress({
+          currentNode: event.currentNode,
+          totalNodes: event.totalNodes,
+          currentEdge: event.currentEdge,
+          totalEdges: event.totalEdges,
+          message: event.message
+        });
+      });
+      transport.on("ingest_complete", (event) => {
+        setIngestProgress({
+          currentNode: event.nodesIngested,
+          totalNodes: event.nodesIngested,
+          currentEdge: event.edgesIngested,
+          totalEdges: event.edgesIngested,
+          message: event.message
+        });
+        setIsIngesting(false);
+        setExtractedNodes([]);
+        setExtractedEdges([]);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.on("error", (event) => {
+        setError(event.message);
+        setIsIngesting(false);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.subscribeToJob(jobId);
+    } catch (err) {
+      setError(String(err));
+      setIsIngesting(false);
+      throw err;
+    }
+  }, [jobId, extractedNodes, options.debug]);
+  const reset = useCallback6(() => {
+    if (transportRef.current) {
+      transportRef.current.disconnect();
+      transportRef.current = null;
+    }
+    setSourceType(null);
+    setDocument(null);
+    setCrawlJob(null);
+    setSelectedLabels([]);
+    setExtractedNodes([]);
+    setExtractedEdges([]);
+    setIsExtracting(false);
+    setExtractionProgress(null);
+    setIsIngesting(false);
+    setIngestProgress(null);
+    setJobId(null);
+    setError(null);
+  }, []);
+  return useMemo6(
+    () => ({
+      sourceType,
+      document,
+      crawlJob,
+      selectedLabels,
+      extractedNodes,
+      extractedEdges,
+      isExtracting,
+      extractionProgress,
+      isIngesting,
+      ingestProgress,
+      jobId,
+      error,
+      uploadDocument,
+      setDocumentUrl,
+      startCrawl,
+      setSelectedLabels,
+      startExtraction,
+      cancelExtraction,
+      removeNode,
+      updateNode,
+      removeEdge,
+      ingestNodes,
+      reset
+    }),
+    [
+      sourceType,
+      document,
+      crawlJob,
+      selectedLabels,
+      extractedNodes,
+      extractedEdges,
+      isExtracting,
+      extractionProgress,
+      isIngesting,
+      ingestProgress,
+      jobId,
+      error,
+      uploadDocument,
+      setDocumentUrl,
+      startCrawl,
+      startExtraction,
+      cancelExtraction,
+      removeNode,
+      updateNode,
+      removeEdge,
+      ingestNodes,
+      reset
+    ]
+  );
+}
+
+// hooks/index.ts
+import { useApiAsync as useApiAsync5, useAsync } from "@elqnt/api-client/hooks";
+
+export {
+  useOptionsRef,
+  useGraphs,
+  useKGQuery,
+  useKGDesigner,
+  useCrawlJobs,
+  useQuickIngest,
+  useFullIngest,
+  useApiAsync5 as useApiAsync,
+  useAsync
+};
+//# sourceMappingURL=chunk-ZEPJC46Z.mjs.map