@personaai/react 0.1.2 → 0.2.0

package/dist/index.js

@@ -41,15 +41,45 @@ function usePersonaContext() {
 }
 
 // src/hooks/useChat.ts
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+function isErrorToolContent(content) {
+  if (typeof content !== "string" || !content.trim().startsWith("{")) return false;
+  try {
+    return JSON.parse(content)?.status === "error";
+  } catch {
+    return false;
+  }
+}
+function normalizePendingInterrupt(pending) {
+  if (!pending || typeof pending !== "object") return null;
+  const p = pending;
+  if (p.kind === "hitl") {
+    return {
+      kind: "hitl",
+      actionRequests: p.value?.actionRequests ?? [],
+      reviewConfigs: p.value?.reviewConfigs ?? []
+    };
+  }
+  if (p.kind === "clarification") {
+    return {
+      kind: "clarification",
+      questions: p.value?.questions ?? []
+    };
+  }
+  return null;
+}
 function useChat(options = {}) {
   const { defaultAgentId, fetchWithAuth } = usePersonaContext();
   const agentId = options.agentId || defaultAgentId;
+  const threadId = options.threadId;
   const [messages, setMessages] = useState(options.initialMessages || []);
   const [input, setInput] = useState("");
   const [isStreaming, setIsStreaming] = useState(false);
+  const [isLoadingHistory, setIsLoadingHistory] = useState(false);
   const [error, setError] = useState(null);
+  const [interrupt, setInterrupt] = useState(null);
   const abortControllerRef = useRef(null);
+  const loadedThreadIdRef = useRef(void 0);
   const stop = useCallback(() => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
@@ -62,6 +92,43 @@ function useChat(options = {}) {
     setMessages([]);
     setError(null);
   }, [stop]);
+  const loadThreadMessages = useCallback(
+    async (id) => {
+      setIsLoadingHistory(true);
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/threads/${id}/messages`);
+        if (!res.ok) throw new Error(`Failed to load thread history: ${res.statusText}`);
+        const body = await res.json();
+        const data = body?.data ?? body;
+        const raw = data?.messages ?? [];
+        const loaded = raw.map((m, i) => ({
+          id: m.id || `history-${id}-${i}`,
+          role: m.role,
+          content: m.content,
+          createdAt: /* @__PURE__ */ new Date(),
+          toolCalls: m.toolCalls
+        }));
+        setMessages(loaded);
+        setInterrupt(normalizePendingInterrupt(data?.pendingInterrupt));
+        return loaded;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        return [];
+      } finally {
+        setIsLoadingHistory(false);
+      }
+    },
+    [fetchWithAuth]
+  );
+  useEffect(() => {
+    if (!threadId || isStreaming) return;
+    if (loadedThreadIdRef.current === threadId) return;
+    if (messages.length > 0) return;
+    loadedThreadIdRef.current = threadId;
+    void loadThreadMessages(threadId);
+  }, [threadId, isStreaming, messages.length, loadThreadMessages]);
   const sendMessage = useCallback(
     async (contentToSend, overrideOptions) => {
       const prompt = (contentToSend ?? input).trim();
@@ -93,6 +160,7 @@ function useChat(options = {}) {
       setInput("");
       setIsStreaming(true);
       setError(null);
+      setInterrupt(null);
       const controller = new AbortController();
       abortControllerRef.current = controller;
       try {
@@ -108,7 +176,8 @@ function useChat(options = {}) {
           body: JSON.stringify({
             agentId: targetAgentId,
             messages: payloadMessages,
-            threadId: overrideOptions?.threadId || options.threadId
+            threadId: overrideOptions?.threadId || options.threadId,
+            resume: overrideOptions?.resume
           }),
           signal: controller.signal
         });
@@ -123,7 +192,15 @@ function useChat(options = {}) {
         const decoder = new TextDecoder("utf-8");
         let buffer = "";
         let accumulatedText = "";
+        let accumulatedReasoning = "";
         const toolCallsMap = /* @__PURE__ */ new Map();
+        const patchAssistant = (patch) => {
+          setMessages(
+            (prev) => prev.map(
+              (msg) => msg.id === assistantMessageId ? { ...msg, toolCalls: Array.from(toolCallsMap.values()), ...patch } : msg
+            )
+          );
+        };
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
@@ -140,47 +217,49 @@ function useChat(options = {}) {
               options.onEvent?.(event);
               if (event.type === "TEXT_MESSAGE_CHUNK" && event.delta) {
                 accumulatedText += event.delta;
-                setMessages(
-                  (prev) => prev.map(
-                    (msg) => msg.id === assistantMessageId ? {
-                      ...msg,
-                      content: accumulatedText,
-                      isStreaming: true,
-                      toolCalls: Array.from(toolCallsMap.values())
-                    } : msg
-                  )
-                );
-              } else if (event.type === "TOOL_CALL_START") {
-                toolCallsMap.set(event.toolCallId, {
-                  toolCallId: event.toolCallId,
-                  toolName: event.toolName,
-                  args: ""
-                });
-                setMessages(
-                  (prev) => prev.map(
-                    (msg) => msg.id === assistantMessageId ? { ...msg, toolCalls: Array.from(toolCallsMap.values()) } : msg
-                  )
-                );
-              } else if (event.type === "TOOL_CALL_ARGS") {
+                patchAssistant({ content: accumulatedText, isStreaming: true });
+              } else if (event.type === "TOOL_CALL_CHUNK" && event.toolCallId) {
                 const existing = toolCallsMap.get(event.toolCallId);
                 if (existing) {
-                  existing.args = (existing.args || "") + event.delta;
-                  setMessages(
-                    (prev) => prev.map(
-                      (msg) => msg.id === assistantMessageId ? { ...msg, toolCalls: Array.from(toolCallsMap.values()) } : msg
-                    )
-                  );
+                  existing.args = (existing.args || "") + (event.delta || "");
+                } else {
+                  toolCallsMap.set(event.toolCallId, {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolCallName || "",
+                    args: event.delta || ""
+                  });
                 }
+                patchAssistant({});
               } else if (event.type === "TOOL_CALL_RESULT") {
                 const existing = toolCallsMap.get(event.toolCallId);
                 if (existing) {
-                  existing.result = event.result;
-                  existing.isError = event.isError;
-                  setMessages(
-                    (prev) => prev.map(
-                      (msg) => msg.id === assistantMessageId ? { ...msg, toolCalls: Array.from(toolCallsMap.values()) } : msg
-                    )
-                  );
+                  existing.result = event.content;
+                  existing.isError = isErrorToolContent(event.content);
+                  patchAssistant({});
+                }
+              } else if (event.type === "REASONING_MESSAGE_CONTENT") {
+                accumulatedReasoning += event.delta;
+                patchAssistant({ reasoning: accumulatedReasoning, isReasoning: true });
+              } else if (event.type === "REASONING_END") {
+                patchAssistant({ isReasoning: false });
+              } else if (event.type === "CUSTOM") {
+                if (event.name === "hitl_request") {
+                  const value2 = event.value;
+                  setInterrupt({
+                    kind: "hitl",
+                    actionRequests: value2.actionRequests,
+                    reviewConfigs: value2.reviewConfigs
+                  });
+                } else if (event.name === "clarification_request") {
+                  const value2 = event.value;
+                  setInterrupt({ kind: "clarification", questions: value2.questions });
+                } else if (event.name === "subagent_activity") {
+                  const { toolCallId, ...entry } = event.value;
+                  const existing = toolCallsMap.get(toolCallId);
+                  if (existing) {
+                    existing.subagentActivity = [...existing.subagentActivity || [], entry];
+                    patchAssistant({});
+                  }
                 }
               } else if (event.type === "RUN_ERROR") {
                 throw new Error(event.message || "Stream error from agent");
@@ -198,7 +277,8 @@ function useChat(options = {}) {
           content: accumulatedText,
           createdAt: /* @__PURE__ */ new Date(),
           isStreaming: false,
-          toolCalls: Array.from(toolCallsMap.values())
+          toolCalls: Array.from(toolCallsMap.values()),
+          ...accumulatedReasoning ? { reasoning: accumulatedReasoning, isReasoning: false } : {}
         };
         setMessages(
           (prev) => prev.map((msg) => msg.id === assistantMessageId ? finalMessage : msg)
@@ -256,6 +336,10 @@ function useChat(options = {}) {
     setMessages(messages.slice(0, lastUserIndex));
     void sendMessage(lastUserMessage.content);
   }, [isStreaming, messages, sendMessage]);
+  const resumeInterrupt = useCallback(
+    (resume, displayContent) => sendMessage(displayContent, { resume }),
+    [sendMessage]
+  );
   return {
     messages,
     input,
@@ -265,19 +349,23 @@ function useChat(options = {}) {
     sendMessage,
     isStreaming,
     isLoading: isStreaming,
+    isLoadingHistory,
     error,
+    interrupt,
+    resumeInterrupt,
     stop,
     reload,
     clear,
-    setMessages
+    setMessages,
+    loadThreadMessages
   };
 }
 
 // src/hooks/useMemory.ts
-import { useCallback as useCallback2, useEffect, useState as useState2 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
 function useMemory(autoFetch = true) {
   const { fetchWithAuth } = usePersonaContext();
-  const [memory, setMemory] = useState2({ user: [], agents: {} });
+  const [memory, setMemory] = useState2({ userFiles: [], agentMemories: [] });
   const [isLoading, setIsLoading] = useState2(false);
   const [error, setError] = useState2(null);
   const fetchMemory = useCallback2(async () => {
@@ -294,7 +382,7 @@ function useMemory(autoFetch = true) {
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
       setError(errorObj);
-      return { user: [], agents: {} };
+      return { userFiles: [], agentMemories: [] };
     } finally {
       setIsLoading(false);
     }
@@ -337,7 +425,7 @@ function useMemory(autoFetch = true) {
     },
     [fetchWithAuth, fetchMemory]
   );
-  useEffect(() => {
+  useEffect2(() => {
     if (autoFetch) {
       void fetchMemory();
     }
@@ -354,7 +442,7 @@ function useMemory(autoFetch = true) {
 }
 
 // src/hooks/useThreads.ts
-import { useCallback as useCallback3, useEffect as useEffect2, useState as useState3 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useState as useState3 } from "react";
 function useThreads(autoFetch = true) {
   const { fetchWithAuth, defaultAgentId } = usePersonaContext();
   const [threads, setThreads] = useState3([]);
@@ -367,7 +455,7 @@ function useThreads(autoFetch = true) {
       const res = await fetchWithAuth("/threads");
       if (!res.ok) throw new Error(`Failed to list threads: ${res.statusText}`);
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.threads || data?.items || [];
+      const items = Array.isArray(data) ? data : data?.items || data?.threads || (Array.isArray(data?.data) ? data.data : void 0) || [];
       setThreads(items);
       return items;
     } catch (err) {
@@ -387,7 +475,8 @@ function useThreads(autoFetch = true) {
         body: JSON.stringify({ agentId: targetAgentId })
       });
       if (!res.ok) throw new Error(`Failed to create thread: ${res.statusText}`);
-      const created = await res.json();
+      const data = await res.json();
+      const created = data?.data ?? data;
       void fetchThreads();
       return created;
     },
@@ -401,7 +490,57 @@ function useThreads(autoFetch = true) {
     },
     [fetchWithAuth]
   );
-  useEffect2(() => {
+  const bulkDeleteThreads = useCallback3(
+    async (threadIds) => {
+      const res = await fetchWithAuth("/threads/bulk-delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: threadIds })
+      });
+      if (!res.ok) throw new Error(`Failed to bulk-delete threads: ${res.statusText}`);
+      const data = await res.json();
+      const result = data?.data ?? data;
+      const deletedSet = new Set(result.deleted);
+      setThreads((prev) => prev.filter((t) => !deletedSet.has(t._id)));
+      return result;
+    },
+    [fetchWithAuth]
+  );
+  const deleteAllThreads = useCallback3(async () => {
+    const ids = threads.map((t) => t._id);
+    for (let i = 0; i < ids.length; i += 100) {
+      await bulkDeleteThreads(ids.slice(i, i + 100));
+    }
+  }, [threads, bulkDeleteThreads]);
+  const updateThread = useCallback3(
+    async (threadId, input) => {
+      const res = await fetchWithAuth(`/threads/${threadId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      });
+      if (!res.ok) throw new Error(`Failed to update thread: ${res.statusText}`);
+      const data = await res.json();
+      const updated = data?.data ?? data;
+      setThreads((prev) => prev.map((t) => t._id === threadId ? { ...t, ...updated } : t));
+      return updated;
+    },
+    [fetchWithAuth]
+  );
+  const renameThread = useCallback3(
+    (threadId, title) => updateThread(threadId, { title }),
+    [updateThread]
+  );
+  const getThread = useCallback3(
+    async (threadId) => {
+      const res = await fetchWithAuth(`/threads/${threadId}`);
+      if (!res.ok) throw new Error(`Failed to fetch thread: ${res.statusText}`);
+      const data = await res.json();
+      return data?.data ?? data;
+    },
+    [fetchWithAuth]
+  );
+  useEffect3(() => {
     if (autoFetch) {
       void fetchThreads();
     }
@@ -412,12 +551,17 @@ function useThreads(autoFetch = true) {
     error,
     refetch: fetchThreads,
     createThread,
-    deleteThread
+    deleteThread,
+    bulkDeleteThreads,
+    deleteAllThreads,
+    updateThread,
+    renameThread,
+    getThread
   };
 }
 
 // src/hooks/useFiles.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect4, useState as useState4 } from "react";
 function useFiles(autoFetch = true) {
   const { fetchWithAuth } = usePersonaContext();
   const [files, setFiles] = useState4([]);
@@ -431,7 +575,7 @@ function useFiles(autoFetch = true) {
       const res = await fetchWithAuth("/files");
       if (!res.ok) throw new Error(`Failed to list files: ${res.statusText}`);
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.files || data?.items || [];
+      const items = Array.isArray(data) ? data : data?.items || data?.files || [];
       setFiles(items);
       return items;
     } catch (err) {
@@ -479,7 +623,21 @@ function useFiles(autoFetch = true) {
     async (fileId) => {
       const res = await fetchWithAuth(`/files/${fileId}`, { method: "DELETE" });
       if (!res.ok) throw new Error(`Failed to delete file: ${res.statusText}`);
-      setFiles((prev) => prev.filter((f) => f._id !== fileId));
+      setFiles((prev) => prev.filter((f) => f.id !== fileId));
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteFiles = useCallback4(
+    async (fileIds) => {
+      const res = await fetchWithAuth("/files/bulk-delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: fileIds })
+      });
+      if (!res.ok) throw new Error(`Failed to bulk-delete files: ${res.statusText}`);
+      const idSet = new Set(fileIds);
+      setFiles((prev) => prev.filter((f) => !idSet.has(f.id)));
+      return await res.json();
     },
     [fetchWithAuth]
   );
@@ -489,7 +647,7 @@ function useFiles(autoFetch = true) {
     },
     []
   );
-  useEffect3(() => {
+  useEffect4(() => {
     if (autoFetch) {
       void fetchFiles();
     }
@@ -502,12 +660,13 @@ function useFiles(autoFetch = true) {
     refetch: fetchFiles,
     uploadFile,
     deleteFile,
+    bulkDeleteFiles,
     getDownloadUrl
   };
 }
 
 // src/hooks/useAgents.ts
-import { useCallback as useCallback5, useEffect as useEffect4, useState as useState5 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect5, useState as useState5 } from "react";
 function useAgents(autoFetch = true) {
   const { fetchWithAuth } = usePersonaContext();
   const [agents, setAgents] = useState5([]);
@@ -520,7 +679,7 @@ function useAgents(autoFetch = true) {
       const res = await fetchWithAuth("/agents");
       if (!res.ok) throw new Error(`Failed to list agents: ${res.statusText}`);
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.agents || data?.items || [];
+      const items = Array.isArray(data) ? data : data?.items || data?.agents || [];
       setAgents(items);
       return items;
     } catch (err) {
@@ -531,7 +690,7 @@ function useAgents(autoFetch = true) {
       setIsLoading(false);
     }
   }, [fetchWithAuth]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (autoFetch) {
       void fetchAgents();
     }
@@ -545,7 +704,7 @@ function useAgents(autoFetch = true) {
 }
 
 // src/hooks/useConnection.ts
-import { useCallback as useCallback6, useEffect as useEffect5, useState as useState6 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect6, useState as useState6 } from "react";
 function useConnection(autoCheck = true) {
   const { fetchWithAuth } = usePersonaContext();
   const [health, setHealth] = useState6(null);
@@ -570,7 +729,7 @@ function useConnection(autoCheck = true) {
       setIsLoading(false);
     }
   }, [fetchWithAuth]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (autoCheck) {
       void checkHealth();
     }
@@ -584,7 +743,7 @@ function useConnection(autoCheck = true) {
 }
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.2.0";
 export {
   PersonaProvider,
   VERSION,