@personaai/react 0.8.1 → 0.9.0

package/dist/index.js

@@ -133,7 +133,8 @@ function fetchReader(response, controller) {
 function xhrStream(opts) {
   return new Promise((resolveStream, rejectStream) => {
     const xhr = new XMLHttpRequest();
-    xhr.open("POST", opts.url);
+    const method = opts.method ?? "POST";
+    xhr.open(method, opts.url);
     for (const [key, val] of Object.entries(opts.headers))
       xhr.setRequestHeader(key, val);
     let consumed = 0;
@@ -232,7 +233,7 @@ function xhrStream(opts) {
         });
       }
     }
-    xhr.send(opts.body);
+    xhr.send(method === "GET" ? null : opts.body ?? null);
   });
 }
 async function openSSEStream(opts) {
@@ -244,10 +245,11 @@ async function openSSEStream(opts) {
     if (opts.signal.aborted) controller.abort();
     else opts.signal.addEventListener("abort", () => controller.abort());
   }
+  const method = opts.method ?? "POST";
   const response = await fetch(opts.url, {
-    method: "POST",
+    method,
     headers: opts.headers,
-    body: opts.body,
+    body: method === "GET" ? void 0 : opts.body,
     signal: controller.signal
   });
   if (!response.ok) {
@@ -2059,6 +2061,592 @@ function useMcp(options = {}) {
   };
 }
 
+// src/hooks/useWorkflows.ts
+import { useCallback as useCallback10, useEffect as useEffect9, useState as useState9 } from "react";
+function useWorkflows(options) {
+  const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
+  const { autoFetch = true, search, status, page, limit } = opts;
+  const { fetchWithAuth } = usePersonaContext();
+  const [workflows, setWorkflows] = useState9([]);
+  const [pagination, setPagination] = useState9({
+    page: page ?? 1,
+    limit: limit ?? 20,
+    total: 0,
+    totalPages: 0
+  });
+  const [isLoading, setIsLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const fetchWorkflows = useCallback10(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const params = new URLSearchParams();
+      if (search) params.set("search", search);
+      if (status) params.set("status", status);
+      if (page) params.set("page", String(page));
+      if (limit) params.set("limit", String(limit));
+      const queryStr = params.toString() ? `?${params.toString()}` : "";
+      const res = await fetchWithAuth(`/workflows${queryStr}`);
+      if (!res.ok) {
+        throw new Error(`Failed to list workflows: ${res.statusText}`);
+      }
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items || data?.workflows || [];
+      setWorkflows(items);
+      if (data?.pagination) {
+        setPagination({
+          page: data.pagination.page ?? 1,
+          limit: data.pagination.limit ?? items.length,
+          total: data.pagination.total ?? items.length,
+          totalPages: data.pagination.totalPages ?? 1
+        });
+      } else {
+        setPagination({
+          page: 1,
+          limit: items.length,
+          total: items.length,
+          totalPages: 1
+        });
+      }
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, search, status, page, limit]);
+  const createWorkflow = useCallback10(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/workflows", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create workflow (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setWorkflows((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  useEffect9(() => {
+    if (autoFetch) {
+      void fetchWorkflows();
+    }
+  }, [autoFetch, fetchWorkflows]);
+  return {
+    workflows,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchWorkflows,
+    createWorkflow
+  };
+}
+
+// src/hooks/useWorkflow.ts
+import { useCallback as useCallback11, useEffect as useEffect10, useState as useState10 } from "react";
+function useWorkflow(workflowId, options) {
+  const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
+  const { autoFetch = true } = opts;
+  const { fetchWithAuth } = usePersonaContext();
+  const [workflow, setWorkflow] = useState10(null);
+  const [versions, setVersions] = useState10([]);
+  const [mermaid, setMermaid] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const fetchWorkflow = useCallback11(async () => {
+    if (!workflowId) return null;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetchWithAuth(`/workflows/${workflowId}`);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch workflow (${res.status}): ${res.statusText}`);
+      }
+      const data = await res.json();
+      setWorkflow(data);
+      return data;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, workflowId]);
+  const fetchVersions = useCallback11(async () => {
+    if (!workflowId) return [];
+    try {
+      const res = await fetchWithAuth(`/workflows/${workflowId}/versions`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items || [];
+      setVersions(items);
+      return items;
+    } catch {
+      return [];
+    }
+  }, [fetchWithAuth, workflowId]);
+  const fetchMermaid = useCallback11(async () => {
+    if (!workflowId) return "";
+    try {
+      const res = await fetchWithAuth(`/workflows/${workflowId}/mermaid`);
+      if (!res.ok) return "";
+      const data = await res.json();
+      const code = typeof data?.mermaid === "string" ? data.mermaid : String(data ?? "");
+      setMermaid(code);
+      return code;
+    } catch {
+      return "";
+    }
+  }, [fetchWithAuth, workflowId]);
+  const saveDraft = useCallback11(
+    async (draft) => {
+      if (!workflowId) throw new Error("Workflow ID is required");
+      setError(null);
+      const res = await fetchWithAuth(`/workflows/${workflowId}/draft`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ draft })
+      });
+      if (!res.ok) {
+        const errText = await res.text().catch(() => res.statusText);
+        throw new Error(`Failed to save draft (${res.status}): ${errText}`);
+      }
+      const updated = await res.json();
+      setWorkflow(updated);
+      return updated;
+    },
+    [fetchWithAuth, workflowId]
+  );
+  const publish = useCallback11(
+    async (summary) => {
+      if (!workflowId) throw new Error("Workflow ID is required");
+      setError(null);
+      const res = await fetchWithAuth(`/workflows/${workflowId}/publish`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(summary ? { summary } : {})
+      });
+      if (!res.ok) {
+        const errText = await res.text().catch(() => res.statusText);
+        throw new Error(`Failed to publish workflow (${res.status}): ${errText}`);
+      }
+      const versionResult = await res.json();
+      void fetchWorkflow();
+      void fetchVersions();
+      return versionResult;
+    },
+    [fetchWithAuth, workflowId, fetchWorkflow, fetchVersions]
+  );
+  const deleteWorkflow = useCallback11(async () => {
+    if (!workflowId) throw new Error("Workflow ID is required");
+    setError(null);
+    const res = await fetchWithAuth(`/workflows/${workflowId}`, {
+      method: "DELETE"
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to delete workflow (${res.status}): ${res.statusText}`);
+    }
+    setWorkflow(null);
+  }, [fetchWithAuth, workflowId]);
+  useEffect10(() => {
+    if (autoFetch && workflowId) {
+      void fetchWorkflow();
+    }
+  }, [autoFetch, workflowId, fetchWorkflow]);
+  return {
+    workflow,
+    versions,
+    mermaid,
+    isLoading,
+    error,
+    refetch: fetchWorkflow,
+    fetchVersions,
+    fetchMermaid,
+    saveDraft,
+    publish,
+    deleteWorkflow
+  };
+}
+
+// src/hooks/useWorkflowStream.ts
+import { useCallback as useCallback12, useEffect as useEffect11, useRef as useRef3, useState as useState11 } from "react";
+function useWorkflowStream(workflowId, options) {
+  const { baseUrl, getAuthToken, fetchWithAuth, logger } = usePersonaContext();
+  const [status, setStatus] = useState11("idle");
+  const [runId, setRunId] = useState11(null);
+  const [activeNodeId, setActiveNodeId] = useState11(null);
+  const [nodeRuns, setNodeRuns] = useState11(
+    {}
+  );
+  const [text, setText] = useState11("");
+  const [output, setOutput] = useState11(null);
+  const [error, setError] = useState11(null);
+  const [events, setEvents] = useState11([]);
+  const abortControllerRef = useRef3(null);
+  const currentRunIdRef = useRef3(null);
+  currentRunIdRef.current = runId;
+  const optionsRef = useRef3(options);
+  optionsRef.current = options;
+  const cancel = useCallback12(async () => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    const currentRun = currentRunIdRef.current;
+    if (currentRun) {
+      try {
+        await fetchWithAuth(`/workflows/runs/${currentRun}/cancel`, {
+          method: "POST"
+        });
+      } catch (err) {
+        logger.warn("Failed to send cancel request to workflow run", {
+          runId: currentRun,
+          error: String(err)
+        });
+      }
+    }
+    setStatus("cancelled");
+    setActiveNodeId(null);
+  }, [fetchWithAuth, logger]);
+  const reset = useCallback12(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setStatus("idle");
+    setRunId(null);
+    setActiveNodeId(null);
+    setNodeRuns({});
+    setText("");
+    setOutput(null);
+    setError(null);
+    setEvents([]);
+  }, []);
+  const processStream = useCallback12(
+    async (url, method, body, targetRunId) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setStatus("running");
+      setError(null);
+      const token = getAuthToken ? await getAuthToken() : null;
+      const headers = {
+        Accept: "text/event-stream"
+      };
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (method === "POST") {
+        headers["Content-Type"] = "application/json";
+      }
+      let assignedRunId = targetRunId ?? null;
+      let accumulatedText = "";
+      let finalOutput = null;
+      try {
+        const stream = await openSSEStream({
+          url,
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        if (!stream.ok) {
+          throw new Error(
+            stream.errorText || `Stream request failed with status ${stream.status}`
+          );
+        }
+        const runIdHeader = stream.getHeader("x-persona-run-id");
+        if (runIdHeader) {
+          assignedRunId = runIdHeader;
+          setRunId(runIdHeader);
+        }
+        let buffer = "";
+        while (true) {
+          const { done, value } = await stream.reader.read();
+          if (done) break;
+          if (!value) continue;
+          buffer += value;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) continue;
+            if (trimmed.startsWith("data:")) {
+              const rawData = trimmed.slice(5).trim();
+              if (!rawData || rawData === "[DONE]") continue;
+              try {
+                const event = JSON.parse(rawData);
+                setEvents((prev) => [...prev, event]);
+                optionsRef.current?.onEvent?.(event);
+                if ("runId" in event && typeof event.runId === "string" && !assignedRunId) {
+                  assignedRunId = event.runId;
+                  setRunId(event.runId);
+                }
+                if (event.type === "TEXT_MESSAGE_CHUNK") {
+                  accumulatedText += event.delta;
+                  setText((prev) => prev + event.delta);
+                } else if (event.type === "CUSTOM") {
+                  if (event.name === "workflow_node_started") {
+                    const val = event.value;
+                    setActiveNodeId(val.nodeId);
+                    setNodeRuns((prev) => ({
+                      ...prev,
+                      [val.nodeId]: {
+                        nodeId: val.nodeId,
+                        nodeType: val.nodeType,
+                        nodeLabel: val.nodeLabel,
+                        status: "running",
+                        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                        input: val.input
+                      }
+                    }));
+                    optionsRef.current?.onNodeStarted?.(val);
+                  } else if (event.name === "workflow_node_completed") {
+                    const val = event.value;
+                    setNodeRuns((prev) => {
+                      const existing = prev[val.nodeId];
+                      return {
+                        ...prev,
+                        [val.nodeId]: {
+                          nodeId: val.nodeId,
+                          nodeType: existing?.nodeType ?? "unknown",
+                          nodeLabel: existing?.nodeLabel ?? val.nodeId,
+                          status: "completed",
+                          startedAt: existing?.startedAt,
+                          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                          input: existing?.input,
+                          output: val.output
+                        }
+                      };
+                    });
+                    setActiveNodeId((curr) => curr === val.nodeId ? null : curr);
+                    finalOutput = val.output;
+                    setOutput(val.output);
+                    optionsRef.current?.onNodeCompleted?.(val);
+                  } else if (event.name === "workflow_node_failed") {
+                    const val = event.value;
+                    setNodeRuns((prev) => {
+                      const existing = prev[val.nodeId];
+                      return {
+                        ...prev,
+                        [val.nodeId]: {
+                          nodeId: val.nodeId,
+                          nodeType: existing?.nodeType ?? "unknown",
+                          nodeLabel: existing?.nodeLabel ?? val.nodeId,
+                          status: "failed",
+                          startedAt: existing?.startedAt,
+                          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                          input: existing?.input,
+                          error: val.error
+                        }
+                      };
+                    });
+                    setActiveNodeId((curr) => curr === val.nodeId ? null : curr);
+                    optionsRef.current?.onNodeFailed?.(val);
+                  }
+                } else if (event.type === "RUN_FINISHED") {
+                  setStatus("completed");
+                  setActiveNodeId(null);
+                  optionsRef.current?.onFinish?.({
+                    runId: assignedRunId || "",
+                    output: finalOutput,
+                    text: accumulatedText
+                  });
+                } else if (event.type === "RUN_ERROR") {
+                  const runErr = new Error(event.message || event.code || "Workflow run error");
+                  setStatus("failed");
+                  setError(runErr);
+                  setActiveNodeId(null);
+                  optionsRef.current?.onError?.(runErr);
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        setStatus((prev) => prev === "running" ? "completed" : prev);
+        return finalOutput;
+      } catch (err) {
+        if (controller.signal.aborted) {
+          setStatus("cancelled");
+          return null;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setStatus("failed");
+        setError(errorObj);
+        setActiveNodeId(null);
+        optionsRef.current?.onError?.(errorObj);
+        throw errorObj;
+      } finally {
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [getAuthToken]
+  );
+  const start = useCallback12(
+    async (input, opts) => {
+      const targetWfId = opts?.workflowId || workflowId;
+      if (!targetWfId) {
+        throw new Error("Workflow ID must be provided to start execution");
+      }
+      setNodeRuns({});
+      setText("");
+      setOutput(null);
+      setEvents([]);
+      setActiveNodeId(null);
+      const cleanBase = baseUrl.replace(/\/+$/, "");
+      const url = `${cleanBase}/workflows/${targetWfId}/stream`;
+      const body = JSON.stringify({
+        input: input ?? {},
+        dryRun: opts?.dryRun ?? false
+      });
+      return processStream(url, "POST", body);
+    },
+    [workflowId, baseUrl, processStream]
+  );
+  const resume = useCallback12(
+    async (targetRunId, sinceSeq) => {
+      if (!targetRunId) {
+        throw new Error("Run ID is required to resume stream");
+      }
+      setRunId(targetRunId);
+      const cleanBase = baseUrl.replace(/\/+$/, "");
+      const query = sinceSeq !== void 0 ? `?since=${sinceSeq}` : "";
+      const url = `${cleanBase}/workflows/runs/${targetRunId}/resume${query}`;
+      await processStream(url, "GET", void 0, targetRunId);
+    },
+    [baseUrl, processStream]
+  );
+  useEffect11(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+  return {
+    runId,
+    status,
+    isRunning: status === "running",
+    activeNodeId,
+    nodeRuns,
+    text,
+    output,
+    error,
+    events,
+    start,
+    cancel,
+    resume,
+    reset
+  };
+}
+
+// src/hooks/useWorkflowRuns.ts
+import { useCallback as useCallback13, useEffect as useEffect12, useState as useState12 } from "react";
+function useWorkflowRuns(workflowId, options) {
+  const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
+  const { autoFetch = true, page = 1, limit = 20 } = opts;
+  const { fetchWithAuth } = usePersonaContext();
+  const [runs, setRuns] = useState12([]);
+  const [pagination, setPagination] = useState12({
+    page,
+    limit,
+    total: 0,
+    totalPages: 0
+  });
+  const [isLoading, setIsLoading] = useState12(false);
+  const [error, setError] = useState12(null);
+  const fetchRuns = useCallback13(async () => {
+    if (!workflowId) return [];
+    setIsLoading(true);
+    setError(null);
+    try {
+      const query = `?page=${page}&limit=${limit}`;
+      const res = await fetchWithAuth(`/workflows/${workflowId}/runs${query}`);
+      if (!res.ok) {
+        throw new Error(`Failed to list workflow runs: ${res.statusText}`);
+      }
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items || data?.runs || [];
+      setRuns(items);
+      if (data?.pagination) {
+        setPagination({
+          page: data.pagination.page ?? page,
+          limit: data.pagination.limit ?? limit,
+          total: data.pagination.total ?? items.length,
+          totalPages: data.pagination.totalPages ?? 1
+        });
+      }
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, workflowId, page, limit]);
+  const getRun = useCallback13(
+    async (runId) => {
+      if (!runId) throw new Error("Run ID is required");
+      const res = await fetchWithAuth(`/workflows/runs/${runId}`);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch workflow run (${res.status}): ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    [fetchWithAuth]
+  );
+  const cancelRun = useCallback13(
+    async (runId) => {
+      if (!runId) throw new Error("Run ID is required");
+      const res = await fetchWithAuth(`/workflows/runs/${runId}/cancel`, {
+        method: "POST"
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to cancel workflow run (${res.status}): ${res.statusText}`);
+      }
+      setRuns(
+        (prev) => prev.map((r) => r._id === runId ? { ...r, status: "cancelled" } : r)
+      );
+    },
+    [fetchWithAuth]
+  );
+  useEffect12(() => {
+    if (autoFetch && workflowId) {
+      void fetchRuns();
+    }
+  }, [autoFetch, workflowId, fetchRuns]);
+  return {
+    runs,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchRuns,
+    getRun,
+    cancelRun
+  };
+}
+
 // src/index.ts
 import {
   createLogger as createLogger2,
@@ -2067,7 +2655,7 @@ import {
   getLogLevel,
   isLevelEnabled
 } from "@personaai/logger";
-var VERSION = "0.8.1";
+var VERSION = "0.9.0";
 export {
   PersonaProvider,
   VERSION,
@@ -2087,6 +2675,10 @@ export {
   useMemory,
   usePersonaContext,
   useThreads,
-  useVoice
+  useVoice,
+  useWorkflow,
+  useWorkflowRuns,
+  useWorkflowStream,
+  useWorkflows
 };
 //# sourceMappingURL=index.js.map