@opengeni/react 3.1.0 → 3.3.2-canary.1

package/dist/{chunk-YJFGAFBD.js → chunk-E5KISKFG.js}

@@ -4,7 +4,7 @@ import {
   groupTimeline,
   isActionableHumanInputRequest,
   sessionStatusFromEvents
-} from "./chunk-D3UIAJKY.js";
+} from "./chunk-JAQ5K7W6.js";
 import {
   useDebouncedCallback,
   useMutationRunner,
@@ -102,24 +102,28 @@ function useSession(sessionId, options = {}) {
   const nextReadGeneration = useRef(0);
   const beginRead = options.beginRead;
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const load = useCallback(async () => {
-    if (!sessionId) {
-      return null;
-    }
-    let readGeneration2 = 0;
-    const fetched = await client.getSession(workspaceId, sessionId, {
-      fresh: true,
-      onRequestStart: () => {
-        readGeneration2 = beginRead?.() ?? ++nextReadGeneration.current;
+  const load = useCallback(
+    async (signal) => {
+      if (!sessionId) {
+        return null;
       }
-    });
-    setOverride(null);
-    return {
-      session: fetched,
-      revision: ++nextReadRevision.current,
-      readGeneration: readGeneration2
-    };
-  }, [beginRead, client, workspaceId, sessionId]);
+      let readGeneration2 = 0;
+      const fetched = await client.getSession(workspaceId, sessionId, {
+        fresh: true,
+        signal,
+        onRequestStart: () => {
+          readGeneration2 = beginRead?.() ?? ++nextReadGeneration.current;
+        }
+      });
+      setOverride(null);
+      return {
+        session: fetched,
+        revision: ++nextReadRevision.current,
+        readGeneration: readGeneration2
+      };
+    },
+    [beginRead, client, workspaceId, sessionId]
+  );
   const { data, loading, error, refresh } = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled
@@ -188,7 +192,7 @@ function useSession(sessionId, options = {}) {
 }
 
 // src/hooks/use-session-events.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { startTransition, useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
 var INITIAL_TAIL_PAGE_SIZE = 1e3;
 var OLDER_PAGE_SIZE = 5e3;
 var NEWER_PAGE_SIZE = 5e3;
@@ -357,7 +361,10 @@ function useSessionEvents(sessionId, options = {}) {
           batchResumeSequence
         );
       }
-      observeSessionStatus(batch, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(batch, sessionStatusRef);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
       const current = eventWindowRef.current;
       const next = boundBrowserSessionEventWindow([...current.events, ...batch]);
       const retained = {
@@ -367,7 +374,7 @@ function useSessionEvents(sessionId, options = {}) {
       eventWindowRef.current = retained;
       setEventWindow(retained);
       oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
-      newestSequenceRef.current = retained.events.at(-1)?.sequence ?? null;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
       if (retained.truncated) {
         hasOlderRef.current = true;
         setHasOlder(true);
@@ -391,17 +398,20 @@ function useSessionEvents(sessionId, options = {}) {
           if (!isCurrent()) {
             return;
           }
-          observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+          const status = observeSessionStatus(window.events, sessionStatusRef);
           const retained = boundBrowserSessionEventWindow(window.events);
           eventWindowRef.current = retained;
-          setEventWindow(retained);
           oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
-          newestSequenceRef.current = retained.events.at(-1)?.sequence ?? window.newestSequence;
+          newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
           hasOlderRef.current = window.hasOlder || retained.truncated;
           hasNewerRef.current = false;
           lastSequenceRef.current = window.newestSequence;
           streamResumeSequenceRef.current = window.newestSequence;
           initialWindowLoadedRef.current = true;
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
           setHasOlder(window.hasOlder || retained.truncated);
           setHasNewer(false);
           setInitialLoading(false);
@@ -450,6 +460,7 @@ function useSessionEvents(sessionId, options = {}) {
           flush();
           setError(cause instanceof Error ? cause : new Error(String(cause)));
           setConnectionState("error");
+          setInitialLoading(false);
         }
       }
     })();
@@ -493,6 +504,7 @@ function useSessionEvents(sessionId, options = {}) {
       const generation = generationRef.current;
       loadingOlderRef.current = true;
       setLoadingOlder(true);
+      let published = false;
       try {
         const window = await loadEventWindow(client, workspaceId, sessionId, {
           before,
@@ -512,7 +524,7 @@ function useSessionEvents(sessionId, options = {}) {
         const current = eventWindowRef.current;
         assertPrependOrder(current.events, window.events);
         streamAbortRef.current?.abort();
-        observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+        const status = observeSessionStatus(window.events, sessionStatusRef);
         const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
           direction: "oldest"
         });
@@ -524,28 +536,54 @@ function useSessionEvents(sessionId, options = {}) {
         if (retainedOldest === null || retainedOldest >= before) {
           throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
         }
-        const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+        const retainedNewest = maxResumeSequenceOrNull(retained.events);
+        const previousNewest = maxResumeSequenceOrNull(current.events);
         eventWindowRef.current = retained;
         markCommitted();
-        setEventWindow(retained);
         oldestSequenceRef.current = retainedOldest;
         newestSequenceRef.current = retainedNewest;
         streamResumeSequenceRef.current = maxResumeSequence(retained.events);
         const olderStillAvailable = window.hasOlder;
         hasOlderRef.current = olderStillAvailable;
-        setHasOlder(olderStillAvailable);
-        if (viewModeRef.current === "history") {
+        const evictedLiveTail = previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+        let newer = null;
+        let enterHistory = false;
+        let reconnectLive = false;
+        if (viewModeRef.current === "history" || evictedLiveTail) {
           const highWater = lastSequenceRef.current;
-          const newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
+          newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
           hasNewerRef.current = newer;
-          setHasNewer(newer);
+          if (evictedLiveTail) {
+            viewModeRef.current = "history";
+            enterHistory = true;
+          }
         } else {
-          setStreamEpoch((epoch) => epoch + 1);
+          reconnectLive = true;
         }
+        loadingOlderRef.current = false;
+        startTransition(() => {
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(olderStillAvailable);
+          if (newer !== null) {
+            setHasNewer(newer);
+          }
+          if (enterHistory) {
+            setViewMode("history");
+          } else if (reconnectLive) {
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+          setLoadingOlder(false);
+        });
+        published = true;
         return olderStillAvailable;
       } finally {
-        loadingOlderRef.current = false;
-        setLoadingOlder(false);
+        if (!published) {
+          loadingOlderRef.current = false;
+          setLoadingOlder(false);
+        }
       }
     }),
     [client, workspaceId, sessionId]
@@ -557,6 +595,7 @@ function useSessionEvents(sessionId, options = {}) {
     const generation = generationRef.current;
     loadingOldestRef.current = true;
     setLoadingOldest(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: 0,
@@ -573,28 +612,38 @@ function useSessionEvents(sessionId, options = {}) {
         return false;
       }
       streamAbortRef.current?.abort();
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
       eventWindowRef.current = retained;
-      setEventWindow(retained);
       oldestSequenceRef.current = retainedOldest;
       newestSequenceRef.current = retainedNewest;
       hasOlderRef.current = false;
-      setHasOlder(false);
       const highWater = Math.max(lastSequenceRef.current, retainedNewest ?? 0);
       lastSequenceRef.current = highWater;
       const newer = window.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
       hasNewerRef.current = newer;
-      setHasNewer(newer);
       initialWindowLoadedRef.current = true;
       viewModeRef.current = "history";
-      setViewMode("history");
+      loadingOldestRef.current = false;
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(false);
+        setHasNewer(newer);
+        setViewMode("history");
+        setLoadingOldest(false);
+      });
+      published = true;
       return newer;
     } finally {
-      loadingOldestRef.current = false;
-      setLoadingOldest(false);
+      if (!published) {
+        loadingOldestRef.current = false;
+        setLoadingOldest(false);
+      }
     }
   }, [client, workspaceId, sessionId]);
   const loadNewer = useCallback2(async () => {
@@ -610,6 +659,7 @@ function useSessionEvents(sessionId, options = {}) {
     const generation = generationRef.current;
     loadingNewerRef.current = true;
     setLoadingNewer(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: afterSequence,
@@ -631,7 +681,7 @@ function useSessionEvents(sessionId, options = {}) {
       }
       const current = eventWindowRef.current;
       assertAppendOrder(current.events, window.events);
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const previousOldest = current.events[0]?.sequence ?? null;
       const next = boundBrowserSessionEventWindow([...current.events, ...window.events], {
         direction: "newest"
@@ -641,33 +691,48 @@ function useSessionEvents(sessionId, options = {}) {
         truncated: current.truncated || next.truncated || window.hasNewer
       };
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
       if (retainedNewest === null || retainedNewest <= afterSequence) {
         throw new Error("@opengeni/react: loadNewer made no durable sequence progress");
       }
       eventWindowRef.current = retained;
-      setEventWindow(retained);
       oldestSequenceRef.current = retainedOldest;
       newestSequenceRef.current = retainedNewest;
       if (retainedOldest !== null && (previousOldest === null || retainedOldest > previousOldest || retained.truncated && retained.events[0]?.type !== "session.created" && retainedOldest > 1)) {
         hasOlderRef.current = true;
-        setHasOlder(true);
       }
+      const rearmedOlder = hasOlderRef.current;
       const highWater = Math.max(lastSequenceRef.current, retainedNewest);
       lastSequenceRef.current = highWater;
       const newer = window.hasNewer || retainedNewest < highWater;
       hasNewerRef.current = newer;
-      setHasNewer(newer);
+      let resumeLive = false;
       if (!newer) {
         streamResumeSequenceRef.current = retainedNewest;
         viewModeRef.current = "live";
-        setViewMode("live");
-        setStreamEpoch((epoch) => epoch + 1);
+        resumeLive = true;
       }
+      loadingNewerRef.current = false;
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(rearmedOlder);
+        setHasNewer(newer);
+        if (resumeLive) {
+          setViewMode("live");
+          setStreamEpoch((epoch) => epoch + 1);
+        }
+        setLoadingNewer(false);
+      });
+      published = true;
       return newer;
     } finally {
-      loadingNewerRef.current = false;
-      setLoadingNewer(false);
+      if (!published) {
+        loadingNewerRef.current = false;
+        setLoadingNewer(false);
+      }
     }
   }, [client, workspaceId, sessionId]);
   const jumpToLatest = useCallback2(async () => {
@@ -676,26 +741,34 @@ function useSessionEvents(sessionId, options = {}) {
     }
     loadingLatestRef.current = true;
     setLoadingLatest(true);
+    let published = false;
     try {
       streamAbortRef.current?.abort();
       hasNewerRef.current = false;
-      setHasNewer(false);
       hasOlderRef.current = false;
-      setHasOlder(false);
       newestSequenceRef.current = null;
       oldestSequenceRef.current = null;
       eventWindowRef.current = EMPTY_EVENT_WINDOW;
-      setEventWindow(EMPTY_EVENT_WINDOW);
       initialWindowLoadedRef.current = false;
       streamResumeSequenceRef.current = after;
-      setInitialLoading(true);
       viewModeRef.current = "live";
-      setViewMode("live");
-      setStreamEpoch((epoch) => epoch + 1);
+      loadingLatestRef.current = false;
+      startTransition(() => {
+        setHasNewer(false);
+        setHasOlder(false);
+        setEventWindow(EMPTY_EVENT_WINDOW);
+        setInitialLoading(true);
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        setLoadingLatest(false);
+      });
+      published = true;
       await Promise.resolve();
     } finally {
-      loadingLatestRef.current = false;
-      setLoadingLatest(false);
+      if (!published) {
+        loadingLatestRef.current = false;
+        setLoadingLatest(false);
+      }
     }
   }, [after, sessionId]);
   const identityMatches = stateStreamKey === streamKey;
@@ -925,7 +998,7 @@ function browserUtf8Bytes(value) {
 function isBrowserUtf8Continuation(value) {
   return (value & 192) === 128;
 }
-function observeSessionStatus(events, ref, setStatus) {
+function observeSessionStatus(events, ref) {
   let latest = null;
   for (const event of events) {
     const status = sessionStatusFromEvents([event]);
@@ -933,9 +1006,9 @@ function observeSessionStatus(events, ref, setStatus) {
       latest = { sequence: event.sequence, status };
     }
   }
-  if (!latest || latest.sequence < ref.current.sequence) return;
+  if (!latest || latest.sequence < ref.current.sequence) return void 0;
   ref.current = latest;
-  setStatus(latest.status);
+  return latest.status;
 }
 async function loadEventWindow(client, workspaceId, sessionId, options) {
   let cursor = options.before;
@@ -989,24 +1062,28 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
       buffer = buffer.slice(boundary);
     }
   }
+  const densityWindow = trimBackwardToGroupTarget(buffer, options.targetGroups);
+  buffer = densityWindow.events;
   const oldest = buffer[0] ?? null;
   const newest = buffer[buffer.length - 1] ?? null;
   return {
     events: buffer,
     oldestSequence: oldest?.sequence ?? null,
     newestSequence: newest ? maxResumeSequence(buffer) : 0,
-    hasOlder: buffer.length > 0 && !reachedStart && oldest?.type !== "session.created"
+    hasOlder: buffer.length > 0 && (densityWindow.trimmed || !reachedStart && oldest?.type !== "session.created")
   };
 }
 function findBoundaryIndex(events) {
   for (let index = 0; index < events.length; index += 1) {
-    const type = events[index].type;
-    if (type === "session.created" || type === "user.message") {
+    if (isTurnBoundary(events[index])) {
       return index;
     }
   }
   return -1;
 }
+function isTurnBoundary(event) {
+  return event.type === "session.created" || event.type === "user.message";
+}
 async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
   let cursor = options.after;
   let buffer = [];
@@ -1027,21 +1104,45 @@ async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
     }
     assertAscending(page);
     buffer = [...buffer, ...page];
-    cursor = page[page.length - 1].sequence;
-    if (page.length < options.pageSize) {
-      reachedEnd = true;
-      break;
-    }
+    cursor = maxResumeSequence(page);
   }
+  const densityWindow = trimForwardToGroupTarget(buffer, options.targetGroups);
+  buffer = densityWindow.events;
   const oldest = buffer[0] ?? null;
   const newest = buffer[buffer.length - 1] ?? null;
   return {
     events: buffer,
     oldestSequence: oldest?.sequence ?? null,
     newestSequence: newest ? maxResumeSequence(buffer) : 0,
-    hasNewer: buffer.length > 0 && !reachedEnd
+    hasNewer: buffer.length > 0 && (densityWindow.trimmed || !reachedEnd)
   };
 }
+function trimBackwardToGroupTarget(events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = events.length - 1; index > 0; index -= 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+function trimForwardToGroupTarget(events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = 1; index < events.length; index += 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(0, index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
 async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
   if (options.signal?.aborted) {
     throw abortError();
@@ -1097,6 +1198,9 @@ function isLogStart(event) {
 function maxResumeSequence(events) {
   return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
 }
+function maxResumeSequenceOrNull(events) {
+  return events.length > 0 ? maxResumeSequence(events) : null;
+}
 function eventResumeSequence(event) {
   const payload = asRecord(event.payload);
   const coalescedUntil = Number(payload.coalescedUntil);
@@ -1141,6 +1245,16 @@ function abortError() {
 // src/hooks/use-file-attachments.ts
 import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
 var isImage = (file) => file.type.startsWith("image/");
+var fallbackAttachmentId = 0;
+function createAttachmentId() {
+  const cryptoSource = globalThis.crypto;
+  if (typeof cryptoSource?.randomUUID === "function") return cryptoSource.randomUUID();
+  fallbackAttachmentId += 1;
+  return `attachment:${Date.now().toString(36)}:${fallbackAttachmentId.toString(36)}`;
+}
+function secureContextRequiredErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "secure_context_required" ? error.code : void 0;
+}
 function useFileAttachments(options = {}) {
   const { client, workspaceId } = useEmbeddedFileAttachments(options);
   const pasteFilter = options.pasteFilter ?? isImage;
@@ -1228,6 +1342,7 @@ function useFileAttachments(options = {}) {
               name: asset.filename,
               contentType: asset.contentType,
               sizeBytes: asset.sizeBytes,
+              errorCode: void 0,
               error: void 0
             } : attachment
           )
@@ -1239,6 +1354,7 @@ function useFileAttachments(options = {}) {
             (attachment) => attachment.id === id ? {
               ...attachment,
               status: "failed",
+              errorCode: secureContextRequiredErrorCode(error),
               error: error instanceof Error ? error.message : String(error)
             } : attachment
           )
@@ -1250,7 +1366,7 @@ function useFileAttachments(options = {}) {
   const addFiles = useCallback3(
     (files) => {
       for (const file of files) {
-        const id = crypto.randomUUID();
+        const id = createAttachmentId();
         sources.current.set(id, file);
         const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
         if (previewUrl) previewUrls.current.set(id, previewUrl);
@@ -1278,7 +1394,7 @@ function useFileAttachments(options = {}) {
       }
       setAttachments(
         (current) => current.map(
-          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", error: void 0 } : attachment
+          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", errorCode: void 0, error: void 0 } : attachment
         )
       );
       startUpload(id, file);
@@ -1322,6 +1438,7 @@ function useFileAttachments(options = {}) {
             sizeBytes: file.sizeBytes,
             status: "ready",
             file,
+            errorCode: void 0,
             error: void 0
           } : {
             id: `restored:${file.id}`,
@@ -1734,13 +1851,24 @@ function useGoal(sessionId, options = {}) {
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef5(0);
   const targetKeyRef = useRef5(null);
+  const loadAbort = useRef5(null);
+  const retireLoads = useCallback5(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
   const load = useCallback5(async () => {
     if (!sessionId) {
       return;
     }
     const ticket = ++generation.current;
+    loadAbort.current?.abort();
+    const controller = new AbortController();
+    loadAbort.current = controller;
     try {
-      const fetched = await client.getGoal(workspaceId, sessionId);
+      const fetched = await client.getGoal(workspaceId, sessionId, {
+        signal: controller.signal
+      });
       if (ticket === generation.current) {
         setGoal(fetched);
         setError(null);
@@ -1757,6 +1885,8 @@ function useGoal(sessionId, options = {}) {
         setError(cause instanceof Error ? cause : new Error(String(cause)));
       }
       setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
     }
   }, [client, workspaceId, sessionId]);
   useEffect5(() => {
@@ -1767,13 +1897,14 @@ function useGoal(sessionId, options = {}) {
       setError(null);
     }
     if (!enabled || !pageLive) {
+      retireLoads();
       setLoading(false);
       return;
     }
     if (sharedFeed) {
       setLoading(false);
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     setLoading(true);
@@ -1781,7 +1912,7 @@ function useGoal(sessionId, options = {}) {
     if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
       void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     let cancelled = false;
@@ -1797,9 +1928,18 @@ function useGoal(sessionId, options = {}) {
     return () => {
       cancelled = true;
       if (timer !== null) clearTimeout(timer);
-      generation.current += 1;
+      retireLoads();
     };
-  }, [load, enabled, pageLive, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
+  }, [
+    load,
+    enabled,
+    pageLive,
+    workspaceId,
+    sessionId,
+    options.pollIntervalMs,
+    retireLoads,
+    sharedFeed
+  ]);
   const scheduleRefresh = useDebouncedCallback(() => void load());
   useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
     enabled,
@@ -1842,11 +1982,11 @@ function useGoal(sessionId, options = {}) {
       return true;
     });
     if (ok) {
-      generation.current += 1;
+      retireLoads();
       setGoal(null);
       setError(null);
     }
-  }, [client, workspaceId, sessionId, run]);
+  }, [client, workspaceId, sessionId, run, retireLoads]);
   return {
     goal,
     isActive: goal?.status === "active",
@@ -2089,24 +2229,28 @@ function useSessionLineage(sessionId, options = {}) {
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const nextReadGeneration = useRef8(0);
   const beginRead = options.beginRead;
-  const load = useCallback8(async () => {
-    if (!sessionId) {
+  const load = useCallback8(
+    async (signal) => {
+      if (!sessionId) {
+        return {
+          lineage: { ancestors: [], children: [], truncated: false },
+          readGeneration: 0
+        };
+      }
+      let readGeneration = 0;
+      const lineage = await client.getSessionLineage(workspaceId, sessionId, {
+        signal,
+        onRequestStart: (sharedReadGeneration) => {
+          readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
+        }
+      });
       return {
-        lineage: { ancestors: [], children: [], truncated: false },
-        readGeneration: 0
+        lineage,
+        readGeneration
       };
-    }
-    let readGeneration = 0;
-    const lineage = await client.getSessionLineage(workspaceId, sessionId, {
-      onRequestStart: (sharedReadGeneration) => {
-        readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
-      }
-    });
-    return {
-      lineage,
-      readGeneration
-    };
-  }, [beginRead, client, workspaceId, sessionId]);
+    },
+    [beginRead, client, workspaceId, sessionId]
+  );
   const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
   const refresh = state.refresh;
   useEffect7(() => {
@@ -2334,4 +2478,4 @@ export {
   isHumanInputEvent,
   useHumanInputRequests
 };
-//# sourceMappingURL=chunk-YJFGAFBD.js.map
+//# sourceMappingURL=chunk-E5KISKFG.js.map