@opengeni/react 3.1.0 → 3.3.2

package/src/components/tip-follow.ts

@@ -200,6 +200,11 @@ export function tipFollowNoteGrowth(
   if (previous <= 0) {
     return { ...state, lastHeight: height };
   }
+  if (height < previous && previous - height <= TIP_FOLLOW_SHRINK_EPS_PX) {
+    // Match viewport-shrink deadband memory: the shell retains the paired
+    // pre-shrink scrollTop and this state retains the corresponding height.
+    return state;
+  }
   if (height <= previous) {
     return { ...state, lastHeight: height };
   }
@@ -441,6 +446,53 @@ export function tipFollowCompensateShrink(
   return Math.max(0, Math.min(maxScroll, scrollTop - delta));
 }
 
+export type TipFollowContentShrinkBaseline = {
+  scrollHeight: number;
+  scrollTop: number;
+};
+
+export type TipFollowContentShrinkObservation = {
+  baseline: TipFollowContentShrinkBaseline | null;
+  compensatedScrollTop: number | null;
+};
+
+/**
+ * Retain the geometry from the first sub-epsilon content-shrink frame until
+ * the cumulative collapse crosses the deadband. Browsers may clamp scrollTop
+ * after every tiny frame, so compensating from the latest DOM top would count
+ * those already-applied clamps twice and make the result animation-cadence
+ * dependent.
+ */
+export function tipFollowObserveContentShrink(
+  baseline: TipFollowContentShrinkBaseline | null,
+  previousHeight: number,
+  previousScrollTop: number,
+  nextHeight: number,
+  clientHeight: number,
+  epsPx: number = TIP_FOLLOW_SHRINK_EPS_PX,
+): TipFollowContentShrinkObservation {
+  if (previousHeight <= 0 || nextHeight >= previousHeight) {
+    return { baseline: null, compensatedScrollTop: null };
+  }
+  const retained = baseline ?? {
+    scrollHeight: previousHeight,
+    scrollTop: previousScrollTop,
+  };
+  if (retained.scrollHeight - nextHeight <= epsPx) {
+    return { baseline: retained, compensatedScrollTop: null };
+  }
+  return {
+    baseline: null,
+    compensatedScrollTop: tipFollowCompensateShrink(
+      retained.scrollTop,
+      retained.scrollHeight,
+      nextHeight,
+      clientHeight,
+      epsPx,
+    ),
+  };
+}
+
 /**
  * Viewport shrank (SessionChrome / composer / window). maxScroll rises by ≈Δc;
  * keep the same tip distance: scrollTop += Δc. Without this, pinned follow only

package/src/components/tooltip.tsx

@@ -8,10 +8,19 @@
  * tips and look like a blank white bubble.
  */
 import { Tooltip as TooltipPrimitive } from "radix-ui";
-import { createContext, useContext, type ComponentProps, type CSSProperties } from "react";
+import {
+  createContext,
+  useContext,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ComponentProps,
+  type CSSProperties,
+} from "react";
 
 import { cn } from "../lib/cn";
-import { usePortalTokenSource, usePortalTokenStyle } from "../lib/use-portal-token-style";
+import { usePortalTokenStyle } from "../lib/use-portal-token-style";
 
 type TooltipSourceContextValue = {
   source: HTMLElement | null;
@@ -28,10 +37,34 @@ function TooltipProvider({
 }
 
 function Tooltip({ children, ...props }: ComponentProps<typeof TooltipPrimitive.Root>) {
-  const source = usePortalTokenSource<HTMLElement>();
+  const { onOpenChange, ...rootProps } = props;
+  const sourceRef = useRef<HTMLElement | null>(null);
+  const sourcePublishedRef = useRef(false);
+  const [source, setSource] = useState<HTMLElement | null>(null);
+  const ref = useRef((node: HTMLElement | null) => {
+    sourceRef.current = node;
+    if (sourcePublishedRef.current) setSource(node);
+  }).current;
+  useLayoutEffect(() => {
+    if (rootProps.open === true || rootProps.defaultOpen === true) {
+      sourcePublishedRef.current = true;
+      setSource(sourceRef.current);
+    }
+  }, [rootProps.defaultOpen, rootProps.open]);
+  const sourceContext = useMemo(() => ({ source, ref }), [ref, source]);
   return (
-    <TooltipSourceContext.Provider value={source}>
-      <TooltipPrimitive.Root data-slot="tooltip" {...props}>
+    <TooltipSourceContext.Provider value={sourceContext}>
+      <TooltipPrimitive.Root
+        data-slot="tooltip"
+        onOpenChange={(open) => {
+          if (open) {
+            sourcePublishedRef.current = true;
+            setSource(sourceRef.current);
+          }
+          onOpenChange?.(open);
+        }}
+        {...rootProps}
+      >
         {children}
       </TooltipPrimitive.Root>
     </TooltipSourceContext.Provider>

package/src/hooks/use-available-models.ts

@@ -43,7 +43,10 @@ export function useAvailableModels(
   options: UseAvailableModelsOptions = {},
 ): UseAvailableModelsResult {
   const client = useOpenGeniClient(options);
-  const load = useCallback(async () => await client.getClientConfig(), [client]);
+  const load = useCallback(
+    async (signal?: AbortSignal) => await client.getClientConfig({ signal }),
+    [client],
+  );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled: options.enabled,
@@ -62,19 +65,22 @@ export function useWorkspaceModelCatalog(
   options: UseWorkspaceModelCatalogOptions,
 ): UseWorkspaceModelCatalogResult {
   const client = useOpenGeniClient(options);
-  const load = useCallback(async () => {
-    if (!options.workspaceId) {
-      return { models: [], defaultModel: null };
-    }
-    const [catalog, config] = await Promise.all([
-      client.getWorkspaceModelCatalog(options.workspaceId),
-      client.getClientConfig(),
-    ]);
-    return {
-      models: catalog.models,
-      defaultModel: config.defaultModel,
-    };
-  }, [client, options.workspaceId]);
+  const load = useCallback(
+    async (signal?: AbortSignal) => {
+      if (!options.workspaceId) {
+        return { models: [], defaultModel: null };
+      }
+      const [catalog, config] = await Promise.all([
+        client.getWorkspaceModelCatalog(options.workspaceId, { signal }),
+        client.getClientConfig({ signal }),
+      ]);
+      return {
+        models: catalog.models,
+        defaultModel: config.defaultModel,
+      };
+    },
+    [client, options.workspaceId],
+  );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled: options.enabled !== false && Boolean(options.workspaceId),

package/src/hooks/use-composer.ts

@@ -569,9 +569,17 @@ function reconcileOptimisticSendFromEvents(
   );
   const triggerEventId = operation.triggerEventId ?? accepted?.id ?? null;
   const turnId = operation.turnId ?? promptTurnIdForTrigger(triggerEventId, events);
+  const acceptedRouting = promptRoutingFromAcceptedEvent(accepted ?? null);
+  const destination =
+    acceptedRouting === "queued_for_execution"
+      ? "queue"
+      : acceptedRouting === "accepted_for_execution" || acceptedRouting === "accepted_for_steering"
+        ? "chat"
+        : operation.destination;
   const needsAdmissionUpdate =
     accepted !== undefined &&
     (operation.state !== "queued" ||
+      operation.destination !== destination ||
       operation.triggerEventId !== triggerEventId ||
       operation.turnId !== turnId ||
       operation.error !== undefined ||
@@ -580,6 +588,7 @@ function reconcileOptimisticSendFromEvents(
     ? {
         ...operation,
         state: "queued",
+        destination,
         triggerEventId,
         turnId,
         error: undefined,
@@ -697,6 +706,7 @@ export function useComposer(
   const targetGeneration = useRef(0);
   const draftReadGeneration = useRef(0);
   const draftReadInFlightRef = useRef<string | null>(null);
+  const draftReadAbortRef = useRef<AbortController | null>(null);
   const draftReadRetryRef = useRef<{
     targetKey: string;
     failures: number;
@@ -733,6 +743,8 @@ export function useComposer(
     if (draftReadRetryRef.current.timer !== null) {
       clearTimeout(draftReadRetryRef.current.timer);
     }
+    draftReadAbortRef.current?.abort();
+    draftReadAbortRef.current = null;
     draftReadRetryRef.current = { targetKey, failures: 0, timer: null };
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
@@ -791,6 +803,11 @@ export function useComposer(
       if (draftReadRetryRef.current.timer !== null) {
         clearTimeout(draftReadRetryRef.current.timer);
       }
+      targetGeneration.current += 1;
+      draftReadGeneration.current += 1;
+      draftReadInFlightRef.current = null;
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = null;
     },
     [],
   );
@@ -929,6 +946,9 @@ export function useComposer(
       draftReadInFlightRef.current = targetKey;
       const generation = targetGeneration.current;
       const readTicket = ++draftReadGeneration.current;
+      const requestAbort = new AbortController();
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = requestAbort;
       const localAtStart = localEditRevision.current;
       const baseAtStart = draftRef.current;
       const policyAtStart = policyRef.current;
@@ -958,7 +978,9 @@ export function useComposer(
         setDraftLoading(true);
       }
       try {
-        const fetched = await client.getComposerDraft(workspaceId, sessionId);
+        const fetched = await client.getComposerDraft(workspaceId, sessionId, {
+          signal: requestAbort.signal,
+        });
         if (
           generation !== targetGeneration.current ||
           targetKeyRef.current !== targetKey ||
@@ -1049,6 +1071,9 @@ export function useComposer(
         if (draftReadInFlightRef.current === targetKey) {
           draftReadInFlightRef.current = null;
         }
+        if (draftReadAbortRef.current === requestAbort) {
+          draftReadAbortRef.current = null;
+        }
       }
     },
     [client, durableDrafts, sessionId, targetKey, workspaceId],
@@ -1463,10 +1488,13 @@ export function useComposer(
         ) {
           return;
         }
+        const acceptedRouting =
+          acceptedResult?.routing ?? promptRoutingFromAcceptedEvent(acceptedEvent);
         const acceptedDestination =
-          acceptedResult?.routing === "queued_for_execution"
+          acceptedRouting === "queued_for_execution"
             ? "queue"
-            : acceptedResult?.routing === "accepted_for_execution"
+            : acceptedRouting === "accepted_for_execution" ||
+                acceptedRouting === "accepted_for_steering"
               ? "chat"
               : operation.destination;
         if (options.events === undefined && acceptedDestination === "chat") {
@@ -2743,6 +2771,24 @@ function asError(cause: unknown): Error {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
 
+function promptRoutingFromAcceptedEvent(
+  event: SessionEvent | null,
+): "accepted_for_execution" | "queued_for_execution" | "accepted_for_steering" | null {
+  if (
+    typeof event?.payload !== "object" ||
+    event.payload === null ||
+    Array.isArray(event.payload)
+  ) {
+    return null;
+  }
+  const routing = (event.payload as Record<string, unknown>).routing;
+  return routing === "accepted_for_execution" ||
+    routing === "queued_for_execution" ||
+    routing === "accepted_for_steering"
+    ? routing
+    : null;
+}
+
 function isDraftConflictError(error: Error): boolean {
   const apiError = error as Partial<OpenGeniApiError>;
   return (

package/src/hooks/use-goal.ts

@@ -83,14 +83,26 @@ export function useGoal(
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef(0);
   const targetKeyRef = useRef<string | null>(null);
+  const loadAbort = useRef<AbortController | null>(null);
+
+  const retireLoads = useCallback(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
 
   const load = useCallback(async (): Promise<void> => {
     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);
@@ -108,6 +120,8 @@ export function useGoal(
         setError(cause instanceof Error ? cause : new Error(String(cause)));
       }
       setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
     }
   }, [client, workspaceId, sessionId]);
 
@@ -119,13 +133,14 @@ export function useGoal(
       setError(null);
     }
     if (!enabled || !pageLive) {
+      retireLoads();
       setLoading(false);
       return;
     }
     if (sharedFeed) {
       setLoading(false);
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     setLoading(true);
@@ -133,7 +148,7 @@ export function useGoal(
     if (pollIntervalMs === undefined || pollIntervalMs <= 0) {
       void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     let cancelled = false;
@@ -149,9 +164,18 @@ export function useGoal(
     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, {
@@ -203,11 +227,11 @@ export function useGoal(
       return true as const;
     });
     if (ok) {
-      generation.current += 1;
+      retireLoads();
       setGoal(null);
       setError(null);
     }
-  }, [client, workspaceId, sessionId, run]);
+  }, [client, workspaceId, sessionId, run, retireLoads]);
 
   return {
     goal,

package/src/hooks/use-last-started-turn-policy.ts

@@ -51,11 +51,17 @@ export function useLastStartedTurnPolicy(
     useOpenGeni(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
 
-  const load = useCallback(async (): Promise<LastStartedTurnPolicy | null> => {
-    if (!sessionId) return null;
-    const turns = await client.listTurns(workspaceId, sessionId, { latestStarted: true });
-    return policyFromTurn(turns[0]);
-  }, [client, workspaceId, sessionId]);
+  const load = useCallback(
+    async (signal?: AbortSignal): Promise<LastStartedTurnPolicy | null> => {
+      if (!sessionId) return null;
+      const turns = await client.listTurns(workspaceId, sessionId, {
+        latestStarted: true,
+        signal,
+      });
+      return policyFromTurn(turns[0]);
+    },
+    [client, workspaceId, sessionId],
+  );
 
   const { data, loading, error, refresh } = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,