@opengeni/react 0.46.1 → 0.52.1

package/dist/{chunk-SRFUT2ZU.js → chunk-FWS3KC3Z.js}

@@ -2,13 +2,14 @@ import {
   buildTimeline,
   groupTimeline,
   sessionStatusFromEvents
-} from "./chunk-LWR4MXSS.js";
+} from "./chunk-JR3QFY6B.js";
 import {
   useDebouncedCallback,
   useMutationRunner,
+  usePageLiveActivity,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-EB67J347.js";
+} from "./chunk-KZ73RL76.js";
 import {
   useEmbeddedFileAttachments,
   useEmbeddedGoal,
@@ -17,7 +18,7 @@ import {
   useEmbeddedSessionLineage,
   useEmbeddedSessionMcpApprovalPolicy,
   useEmbeddedSessionRead
-} from "./chunk-EKZH6IDG.js";
+} from "./chunk-HDBG7XGO.js";
 
 // src/hooks/use-session.ts
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -152,6 +153,8 @@ var EMPTY_EVENT_WINDOW = {
 function useSessionEvents(sessionId, options = {}) {
   const { client, workspaceId, reconcileSession } = useEmbeddedSession(options);
   const enabled = options.enabled ?? true;
+  const pageLive = usePageLiveActivity();
+  const streamEnabled = enabled && pageLive;
   const after = options.after ?? 0;
   const replay = options.replay ?? "windowed";
   const fullReplay = replay === "full" || after !== 0;
@@ -228,7 +231,7 @@ function useSessionEvents(sessionId, options = {}) {
       loadingOlderRef.current = false;
       setLoadingOlder(false);
     }
-    if (!sessionId || !enabled) {
+    if (!sessionId || !streamEnabled) {
       setConnectionState("idle");
       return;
     }
@@ -323,7 +326,13 @@ function useSessionEvents(sessionId, options = {}) {
         const stream = client.streamEvents(workspaceId, sessionId, {
           after: streamResumeSequenceRef.current,
           signal: controller.signal,
-          beforeLive: async () => await reconcileSession(sessionId),
+          onOpen: () => {
+            void Promise.resolve().then(() => reconcileSession(sessionId)).catch((cause) => {
+              if (isCurrent()) {
+                setError(cause instanceof Error ? cause : new Error(String(cause)));
+              }
+            });
+          },
           onStateChange: (state) => {
             if (isCurrent()) {
               setConnectionState(state);
@@ -375,7 +384,7 @@ function useSessionEvents(sessionId, options = {}) {
     workspaceId,
     sessionId,
     after,
-    enabled,
+    streamEnabled,
     fullReplay,
     streamKey,
     streamEpoch,
@@ -956,7 +965,7 @@ async function loadPreviousPage(client, workspaceId, sessionId, before, options)
     compact: true,
     // Monitoring summaries omit correlation fields once a bounded durable
     // payload exceeds their preview threshold. The browser timeline needs the
-    // sanitized stored payload so persisted tool outputs still match their
+    // exact stored payload so persisted tool outputs still match their
     // calls and expose truthful truncation telemetry after a reload.
     payloadMode: "full"
   });
@@ -1039,20 +1048,61 @@ function abortError() {
 }
 
 // src/hooks/use-file-attachments.ts
-import { useCallback as useCallback3, useRef as useRef2, useState as useState3 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 var isImage = (file) => file.type.startsWith("image/");
 function useFileAttachments(options = {}) {
   const { client, workspaceId } = useEmbeddedFileAttachments(options);
   const pasteFilter = options.pasteFilter ?? isImage;
   const [attachments, setAttachments] = useState3([]);
   const sources = useRef2(/* @__PURE__ */ new Map());
+  const previewUrls = useRef2(/* @__PURE__ */ new Map());
+  const revokePreview = useCallback3((id) => {
+    const previewUrl = previewUrls.current.get(id);
+    if (!previewUrl) return;
+    previewUrls.current.delete(id);
+    URL.revokeObjectURL(previewUrl);
+  }, []);
+  const revokeAllPreviews = useCallback3(() => {
+    const urls = [...previewUrls.current.values()];
+    previewUrls.current.clear();
+    for (const previewUrl of urls) URL.revokeObjectURL(previewUrl);
+  }, []);
+  const committedAttachmentIds = useRef2(/* @__PURE__ */ new Set());
+  useEffect3(() => {
+    const currentIds = new Set(attachments.map((attachment) => attachment.id));
+    for (const id of committedAttachmentIds.current) {
+      if (!currentIds.has(id)) revokePreview(id);
+    }
+    committedAttachmentIds.current = currentIds;
+  }, [attachments, revokePreview]);
+  const scopeGeneration = useRef2(0);
+  const previousScope = useRef2({ client, workspaceId });
+  useEffect3(() => {
+    const previous = previousScope.current;
+    if (previous.client === client && previous.workspaceId === workspaceId) return;
+    previousScope.current = { client, workspaceId };
+    scopeGeneration.current += 1;
+    sources.current.clear();
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [client, revokeAllPreviews, workspaceId]);
+  useEffect3(
+    () => () => {
+      scopeGeneration.current += 1;
+      sources.current.clear();
+      revokeAllPreviews();
+    },
+    [revokeAllPreviews]
+  );
   const startUpload = useCallback3(
     (id, file) => {
+      const generation = scopeGeneration.current;
       void client.uploadFile(workspaceId, {
         filename: file.name || "file",
         contentType: file.type || "application/octet-stream",
         data: file
       }).then((asset) => {
+        if (scopeGeneration.current !== generation) return;
         sources.current.delete(id);
         setAttachments(
           (current) => current.map(
@@ -1068,6 +1118,7 @@ function useFileAttachments(options = {}) {
           )
         );
       }).catch((error) => {
+        if (scopeGeneration.current !== generation) return;
         setAttachments(
           (current) => current.map(
             (attachment) => attachment.id === id ? {
@@ -1087,6 +1138,7 @@ function useFileAttachments(options = {}) {
         const id = crypto.randomUUID();
         sources.current.set(id, file);
         const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
+        if (previewUrl) previewUrls.current.set(id, previewUrl);
         setAttachments((current) => [
           ...current,
           {
@@ -1167,51 +1219,33 @@ function useFileAttachments(options = {}) {
             // only authority restored across page/device boundaries.
           };
         });
-        for (const [fileId, attachment] of existingReady) {
-          if (!incoming.has(fileId) && attachment.previewUrl) {
-            URL.revokeObjectURL(attachment.previewUrl);
-          }
-        }
         return [...unresolved, ...restored];
       });
     },
     [workspaceId]
   );
-  const remove = useCallback3((id) => {
-    sources.current.delete(id);
-    setAttachments((current) => {
-      const removed = current.find((attachment) => attachment.id === id);
-      if (removed?.previewUrl) {
-        URL.revokeObjectURL(removed.previewUrl);
-      }
-      return current.filter((attachment) => attachment.id !== id);
-    });
-  }, []);
+  const remove = useCallback3(
+    (id) => {
+      sources.current.delete(id);
+      revokePreview(id);
+      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    },
+    [revokePreview]
+  );
   const removeReadyFiles = useCallback3((fileIds) => {
     const accepted = new Set(fileIds);
     if (accepted.size === 0) return;
     setAttachments(
       (current) => current.filter((attachment) => {
-        const removeAccepted = attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id);
-        if (removeAccepted) {
-          sources.current.delete(attachment.id);
-          if (attachment.previewUrl) URL.revokeObjectURL(attachment.previewUrl);
-        }
-        return !removeAccepted;
+        return !(attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id));
       })
     );
   }, []);
   const clear = useCallback3(() => {
     sources.current.clear();
-    setAttachments((current) => {
-      for (const attachment of current) {
-        if (attachment.previewUrl) {
-          URL.revokeObjectURL(attachment.previewUrl);
-        }
-      }
-      return [];
-    });
-  }, []);
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [revokeAllPreviews]);
   return {
     attachments,
     readyResources: attachments.flatMap(
@@ -1230,7 +1264,7 @@ function useFileAttachments(options = {}) {
 }
 
 // src/hooks/use-turn-queue.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect4, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState4 } from "react";
 function isTurnQueueEvent(event) {
   return event.type.startsWith("turn.") || event.type.startsWith("session.queue.") || event.type.startsWith("session.control.") || event.type.startsWith("system.update.") || event.type.startsWith("workspace.inference.");
 }
@@ -1244,6 +1278,7 @@ function useTurnQueue(sessionId, options = {}) {
   const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSession(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pageLive = usePageLiveActivity();
   const [snapshot, setSnapshot] = useState4(null);
   const [stateTargetKey, setStateTargetKey] = useState4(targetKey);
   const [loading, setLoading] = useState4(enabled);
@@ -1312,29 +1347,39 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, acceptSnapshot]
   );
-  useEffect3(() => {
-    if (!enabled) {
+  useEffect4(() => {
+    if (!enabled || !pageLive) {
       setLoading(false);
       return;
     }
     setLoading(true);
-    void load();
     const pollIntervalMs = options.pollIntervalMs;
     if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      void load();
       return () => {
         readGeneration.current += 1;
       };
     }
-    const timer = setInterval(() => void load(), pollIntervalMs);
+    let cancelled = false;
+    let timer = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
     return () => {
-      clearInterval(timer);
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
       readGeneration.current += 1;
     };
-  }, [load, enabled, options.pollIntervalMs]);
-  useEffect3(() => {
+  }, [load, enabled, pageLive, options.pollIntervalMs]);
+  useEffect4(() => {
     if (enabled && workspaceControlEvent) void load();
   }, [enabled, load, workspaceControlEvent]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "queue", load);
   }, [enabled, load, registerSessionReconciler, sessionId]);
@@ -1491,7 +1536,7 @@ function asError(cause) {
 
 // src/hooks/use-goal.ts
 import { OpenGeniApiError } from "@opengeni/sdk";
-import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef4, useState as useState5 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
 function isGoalEvent(event) {
   return event.type.startsWith("goal.");
 }
@@ -1504,6 +1549,7 @@ function useGoal(sessionId, options = {}) {
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const sharedEvents = options.events;
   const sharedFeed = sharedEvents !== void 0;
+  const pageLive = usePageLiveActivity();
   const [goal, setGoal] = useState5(null);
   const [loading, setLoading] = useState5(enabled);
   const [error, setError] = useState5(null);
@@ -1535,14 +1581,14 @@ function useGoal(sessionId, options = {}) {
       setLoading(false);
     }
   }, [client, workspaceId, sessionId]);
-  useEffect4(() => {
+  useEffect5(() => {
     const targetKey = `${workspaceId} ${sessionId ?? ""}`;
     if (targetKeyRef.current !== targetKey) {
       targetKeyRef.current = targetKey;
       setGoal(null);
       setError(null);
     }
-    if (!enabled) {
+    if (!enabled || !pageLive) {
       setLoading(false);
       return;
     }
@@ -1553,19 +1599,29 @@ function useGoal(sessionId, options = {}) {
       };
     }
     setLoading(true);
-    void load();
     const pollIntervalMs = options.pollIntervalMs;
     if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      void load();
       return () => {
         generation.current += 1;
       };
     }
-    const timer = setInterval(() => void load(), pollIntervalMs);
+    let cancelled = false;
+    let timer = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
     return () => {
-      clearInterval(timer);
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
       generation.current += 1;
     };
-  }, [load, enabled, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
+  }, [load, enabled, pageLive, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
   const scheduleRefresh = useDebouncedCallback(() => void load());
   useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
     enabled,
@@ -1632,7 +1688,7 @@ function useGoal(sessionId, options = {}) {
 }
 
 // src/hooks/use-session-lineage.ts
-import { useCallback as useCallback6, useEffect as useEffect5, useRef as useRef5 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect6, useRef as useRef5 } from "react";
 function isLineageRefreshEvent(event) {
   if (event.type === "session.status.changed" || event.type === "session.created") {
     return true;
@@ -1661,16 +1717,16 @@ function useSessionLineage(sessionId, options = {}) {
   );
   const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
   const refresh = state.refresh;
-  useEffect5(() => {
+  useEffect6(() => {
     if (enabled && workspaceControlEvent) void refresh();
   }, [enabled, refresh, workspaceControlEvent]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "lineage", refresh);
   }, [enabled, refresh, registerSessionReconciler, sessionId]);
   const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
   const delayedChildRefreshRef = useRef5(null);
-  useEffect5(() => {
+  useEffect6(() => {
     return () => {
       if (delayedChildRefreshRef.current !== null) {
         clearTimeout(delayedChildRefreshRef.current);
@@ -1814,7 +1870,7 @@ function useSessionControl(sessionId, options = {}) {
 }
 
 // src/hooks/use-session-mcp-approval-policy.ts
-import { useCallback as useCallback8, useEffect as useEffect6, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef7, useState as useState6 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect7, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef7, useState as useState6 } from "react";
 function isSessionMcpApprovalPolicyEvent(event, serverId) {
   if (event.type !== "session.mcp.approval_policy.updated") {
     return false;
@@ -1858,7 +1914,7 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
     enabled,
     pollIntervalMs: options.pollIntervalMs
   });
-  useEffect6(() => {
+  useEffect7(() => {
     if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
       setOverride(null);
     }
@@ -2008,7 +2064,7 @@ function isRecord(value) {
 }
 
 // src/hooks/use-human-input.ts
-import { useCallback as useCallback9, useEffect as useEffect7, useRef as useRef8, useState as useState7 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect8, useRef as useRef8, useState as useState7 } from "react";
 function isHumanInputEvent(event) {
   return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
 }
@@ -2026,11 +2082,11 @@ function useHumanInputRequests(sessionId, options = {}) {
   const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
   const [respondingRequestId, setRespondingRequestId] = useState7(null);
   const respondingRequestRef = useRef8(null);
-  useEffect7(() => {
+  useEffect8(() => {
     respondingRequestRef.current = null;
     setRespondingRequestId(null);
   }, [sessionId, workspaceId]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "human-input", state.refresh);
   }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
@@ -2102,4 +2158,4 @@ export {
   isHumanInputEvent,
   useHumanInputRequests
 };
-//# sourceMappingURL=chunk-SRFUT2ZU.js.map
+//# sourceMappingURL=chunk-FWS3KC3Z.js.map