@opengeni/react 0.1.0

package/src/hooks/use-file-attachments.ts

@@ -0,0 +1,135 @@
+import type { FileAsset, FileResourceRef } from "@opengeni/sdk";
+import { useCallback, useState } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+
+export type UseFileAttachmentsOptions = ClientOverride & {
+  /**
+   * Only files matching this predicate are accepted by {@link
+   * UseFileAttachmentsResult.addFromPaste} (the clipboard path). Defaults to
+   * `image/*` — the console's historical paste filter. {@link
+   * UseFileAttachmentsResult.addFiles} (the explicit picker / drop path)
+   * bypasses it.
+   */
+  pasteFilter?: ((file: File) => boolean) | undefined;
+};
+
+export type FileAttachment = {
+  id: string;
+  name: string;
+  contentType: string;
+  sizeBytes: number;
+  status: "uploading" | "ready" | "failed";
+  /** The SDK `FileAsset` once the upload finishes. */
+  file?: FileAsset | undefined;
+  /** Object-URL for an inline preview; minted for `image/*` files only. */
+  previewUrl?: string | undefined;
+  error?: string | undefined;
+};
+
+export type UseFileAttachmentsResult = {
+  attachments: FileAttachment[];
+  /**
+   * `FileResourceRef[]` for every attachment that finished uploading — feed
+   * straight into `useComposer`'s `sendExtras.resources`.
+   */
+  readyResources: FileResourceRef[];
+  /** True while any attachment is still uploading (drives the send-gate). */
+  uploading: boolean;
+  /** Explicit picker / drop path — uploads every file, no filter. */
+  addFiles: (files: Iterable<File>) => void;
+  /** Clipboard path — applies `pasteFilter` (default `image/*`) then uploads. */
+  addFromPaste: (event: { clipboardData: DataTransfer | null }) => void;
+  /** Remove one attachment; revokes its object-URL. */
+  remove: (id: string) => void;
+  /** Remove all; revokes every object-URL. Call from `useComposer`'s `onSent`. */
+  clear: () => void;
+};
+
+const isImage = (file: File): boolean => file.type.startsWith("image/");
+
+/**
+ * Upload-and-track state for files attached to the next message. Owns the
+ * full client-side upload layer: a per-file `uploading | ready | failed`
+ * status machine driven by the SDK's `client.uploadFile`, object-URL image
+ * previews with create/revoke lifecycle, the `image/*` clipboard paste filter,
+ * and a `FileResourceRef[]` projection that drops straight into a message's
+ * `resources`. Workspace-scoped, so it resolves both client and workspace from
+ * the {@link OpenGeniProvider} (or a per-call `{ client, workspaceId }`).
+ */
+export function useFileAttachments(options: UseFileAttachmentsOptions = {}): UseFileAttachmentsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const pasteFilter = options.pasteFilter ?? isImage;
+  const [attachments, setAttachments] = useState<FileAttachment[]>([]);
+
+  const addFiles = useCallback((files: Iterable<File>) => {
+    for (const file of files) {
+      const id = crypto.randomUUID();
+      const previewUrl = isImage(file) ? URL.createObjectURL(file) : undefined;
+      setAttachments((current) => [...current, {
+        id,
+        name: file.name || "image",
+        contentType: file.type || "application/octet-stream",
+        sizeBytes: file.size,
+        status: "uploading",
+        ...(previewUrl ? { previewUrl } : {}),
+      }]);
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file,
+      }).then((asset) => {
+        setAttachments((current) => current.map((attachment) => attachment.id === id
+          ? { ...attachment, status: "ready", file: asset, name: asset.filename, contentType: asset.contentType, sizeBytes: asset.sizeBytes }
+          : attachment));
+      }).catch((error: unknown) => {
+        setAttachments((current) => current.map((attachment) => attachment.id === id
+          ? { ...attachment, status: "failed", error: error instanceof Error ? error.message : String(error) }
+          : attachment));
+      });
+    }
+  }, [client, workspaceId]);
+
+  const addFromPaste = useCallback((event: { clipboardData: DataTransfer | null }) => {
+    const clipboardFiles = event.clipboardData?.files;
+    if (!clipboardFiles) {
+      return;
+    }
+    const files = [...clipboardFiles].filter(pasteFilter);
+    if (files.length > 0) {
+      addFiles(files);
+    }
+  }, [addFiles, pasteFilter]);
+
+  const remove = useCallback((id: string) => {
+    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 clear = useCallback(() => {
+    setAttachments((current) => {
+      for (const attachment of current) {
+        if (attachment.previewUrl) {
+          URL.revokeObjectURL(attachment.previewUrl);
+        }
+      }
+      return [];
+    });
+  }, []);
+
+  return {
+    attachments,
+    readyResources: attachments.flatMap((attachment): FileResourceRef[] => attachment.status === "ready" && attachment.file
+      ? [{ kind: "file", fileId: attachment.file.id }]
+      : []),
+    uploading: attachments.some((attachment) => attachment.status === "uploading"),
+    addFiles,
+    addFromPaste,
+    remove,
+    clear,
+  };
+}

package/src/hooks/use-goal.ts

@@ -0,0 +1,154 @@
+import { OpenGeniApiError, type SessionEvent, type SessionGoal } from "@opengeni/sdk";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { useDebouncedCallback, useMutationRunner, useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
+
+/** Event types that change the session goal (set/updated/completed/paused/...). */
+export function isGoalEvent(event: Pick<SessionEvent, "type">): boolean {
+  return event.type.startsWith("goal.");
+}
+
+export type UseGoalOptions = ClientOverride & SessionEventFeedOptions & {
+  /** Optional safety-net polling (ms). Off by default — goal.* events drive updates. */
+  pollIntervalMs?: number | undefined;
+};
+
+export type UseGoalResult = {
+  /** The session goal, or null when the session has none. */
+  goal: SessionGoal | null;
+  /** Convenience flags over `goal.status`. */
+  isActive: boolean;
+  isPaused: boolean;
+  isCompleted: boolean;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  /** Pause the goal loop (PATCH status=paused). */
+  pause: (rationale?: string) => Promise<SessionGoal | null>;
+  /** Resume a paused goal: resets counters and re-arms continuations. */
+  resume: () => Promise<SessionGoal | null>;
+  /** True while a pause/resume is in flight. */
+  updating: boolean;
+  mutationError: Error | null;
+  clearMutationError: () => void;
+};
+
+/**
+ * The session's goal: state, the autonomy counters (`autoContinuations`,
+ * `noProgressStreak`), and pause/resume control. A goal-less session yields
+ * `goal: null` (the 404 is absorbed). Live-updates on `goal.*` events —
+ * pass `options.events` from `useSessionEvents` to reuse its stream.
+ */
+export function useGoal(sessionId: string | null | undefined, options: UseGoalOptions = {}): UseGoalResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [goal, setGoal] = useState<SessionGoal | null>(null);
+  const [loading, setLoading] = useState(enabled);
+  const [error, setError] = useState<Error | null>(null);
+  const mutation = useMutationRunner();
+  const generation = useRef(0);
+  const targetKeyRef = useRef<string | null>(null);
+
+  const load = useCallback(async (): Promise<void> => {
+    if (!sessionId) {
+      return;
+    }
+    const ticket = ++generation.current;
+    try {
+      const fetched = await client.getGoal(workspaceId, sessionId);
+      if (ticket === generation.current) {
+        setGoal(fetched);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket !== generation.current) {
+        return;
+      }
+      if (cause instanceof OpenGeniApiError && cause.status === 404) {
+        // No goal is a normal state, not an error.
+        setGoal(null);
+        setError(null);
+      } else {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+      setLoading(false);
+    }
+  }, [client, workspaceId, sessionId]);
+
+  useEffect(() => {
+    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      setGoal(null);
+      setError(null);
+    }
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    void load();
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === undefined || pollIntervalMs <= 0) {
+      return () => {
+        generation.current += 1;
+      };
+    }
+    const timer = setInterval(() => void load(), pollIntervalMs);
+    return () => {
+      clearInterval(timer);
+      generation.current += 1;
+    };
+  }, [load, enabled, workspaceId, sessionId, options.pollIntervalMs]);
+
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(client, workspaceId, sessionId, isGoalEvent, scheduleRefresh, {
+    enabled,
+    ...(options.events !== undefined ? { events: options.events } : {}),
+  });
+
+  const pause = useCallback(
+    async (rationale?: string): Promise<SessionGoal | null> => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await mutation.run(() =>
+        client.updateGoal(workspaceId, sessionId, {
+          status: "paused",
+          ...(rationale !== undefined ? { rationale } : {}),
+        }));
+      if (result) {
+        setGoal(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, mutation.run],
+  );
+
+  const resume = useCallback(async (): Promise<SessionGoal | null> => {
+    if (!sessionId) {
+      return null;
+    }
+    const result = await mutation.run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    if (result) {
+      setGoal(result);
+    }
+    return result;
+  }, [client, workspaceId, sessionId, mutation.run]);
+
+  return {
+    goal,
+    isActive: goal?.status === "active",
+    isPaused: goal?.status === "paused",
+    isCompleted: goal?.status === "completed",
+    loading,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    updating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError,
+  };
+}

package/src/hooks/use-packs.ts

@@ -0,0 +1,101 @@
+import type {
+  CapabilityPack,
+  EnablePackRequest,
+  PackInstallation,
+  RegisterCapabilityPackRequest,
+  WorkspaceRegisteredPack,
+} from "@opengeni/sdk";
+import { useCallback } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { useMutationRunner, usePolledValue } from "./internal";
+
+export type UsePacksOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UsePacksResult = {
+  /** Built-in + registered packs available to the workspace. */
+  packs: CapabilityPack[];
+  /** Enable/disable state per pack. */
+  installations: PackInstallation[];
+  /** The installation for a pack id, if any. */
+  installationFor: (packId: string) => PackInstallation | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  /** Register (or replace) a workspace-scoped pack manifest. */
+  register: (manifest: RegisterCapabilityPackRequest) => Promise<WorkspaceRegisteredPack | null>;
+  enable: (packId: string, request?: EnablePackRequest) => Promise<PackInstallation | null>;
+  /** Unregister a workspace-scoped pack (built-ins cannot be removed). */
+  remove: (packId: string) => Promise<boolean>;
+  mutating: boolean;
+  mutationError: Error | null;
+  clearMutationError: () => void;
+};
+
+/** Capability packs: catalog + installations + register/enable/unregister. */
+export function usePacks(options: UsePacksOptions = {}): UsePacksResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(async () => await client.listPacks(workspaceId), [client, workspaceId]);
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  const mutation = useMutationRunner();
+
+  const register = useCallback(
+    async (manifest: RegisterCapabilityPackRequest): Promise<WorkspaceRegisteredPack | null> => {
+      const result = await mutation.run(() => client.registerPack(workspaceId, manifest));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh],
+  );
+
+  const enable = useCallback(
+    async (packId: string, request: EnablePackRequest = {}): Promise<PackInstallation | null> => {
+      const result = await mutation.run(() => client.enablePack(workspaceId, packId, request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh],
+  );
+
+  const remove = useCallback(
+    async (packId: string): Promise<boolean> => {
+      const result = await mutation.run(async () => {
+        await client.deletePack(workspaceId, packId);
+        return true;
+      });
+      if (result) {
+        await state.refresh();
+      }
+      return result === true;
+    },
+    [client, workspaceId, mutation.run, state.refresh],
+  );
+
+  const installations = state.data?.installations ?? [];
+  const installationFor = useCallback(
+    (packId: string): PackInstallation | null =>
+      installations.find((installation) => installation.packId === packId) ?? null,
+    [installations],
+  );
+
+  return {
+    packs: state.data?.packs ?? [],
+    installations,
+    installationFor,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    register,
+    enable,
+    remove,
+    mutating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError,
+  };
+}

package/src/hooks/use-scheduled-tasks.ts

@@ -0,0 +1,29 @@
+import type { ScheduledTask } from "@opengeni/sdk";
+import { useCallback } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { usePolledValue } from "./internal";
+
+export type UseScheduledTasksOptions = ClientOverride & {
+  limit?: number | undefined;
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseScheduledTasksResult = {
+  tasks: ScheduledTask[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+};
+
+/** List the workspace's scheduled tasks (drift checks, sentinels, reapers, ...). */
+export function useScheduledTasks(options: UseScheduledTasksOptions = {}): UseScheduledTasksResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const limit = options.limit;
+  const load = useCallback(
+    async () => await client.listScheduledTasks(workspaceId, limit !== undefined ? { limit } : {}),
+    [client, workspaceId, limit],
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  return { tasks: state.data ?? [], loading: state.loading, error: state.error, refresh: state.refresh };
+}

package/src/hooks/use-session-control.ts

@@ -0,0 +1,85 @@
+import type { SessionEvent } from "@opengeni/sdk";
+import { useCallback } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { useMutationRunner } from "./internal";
+
+export type UseSessionControlOptions = ClientOverride;
+
+export type UseSessionControlResult = {
+  /** Interrupt the running turn (the explicit alternative to queueing). */
+  interrupt: (reason?: string) => Promise<SessionEvent | null>;
+  interrupting: boolean;
+  /** Approve a pending `requires_action` approval. */
+  approve: (approvalId: string, message?: string) => Promise<SessionEvent | null>;
+  /** Reject a pending `requires_action` approval. */
+  reject: (approvalId: string, message?: string) => Promise<SessionEvent | null>;
+  /** True while an approval decision is in flight. */
+  responding: boolean;
+  error: Error | null;
+  clearError: () => void;
+};
+
+/**
+ * Session control events: interrupt and approval decisions. Pair with
+ * `useSessionEvents` (for `session.requiresAction` payloads carrying the
+ * `approvalId`) to render an approval bar.
+ */
+export function useSessionControl(
+  sessionId: string | null | undefined,
+  options: UseSessionControlOptions = {},
+): UseSessionControlResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const interruptMutation = useMutationRunner();
+  const approvalMutation = useMutationRunner();
+
+  const interrupt = useCallback(
+    async (reason?: string): Promise<SessionEvent | null> => {
+      if (!sessionId) {
+        return null;
+      }
+      return await interruptMutation.run(() =>
+        client.interrupt(workspaceId, sessionId, reason !== undefined ? { reason } : {}));
+    },
+    [client, workspaceId, sessionId, interruptMutation.run],
+  );
+
+  const decide = useCallback(
+    async (approvalId: string, decision: "approve" | "reject", message?: string): Promise<SessionEvent | null> => {
+      if (!sessionId) {
+        return null;
+      }
+      return await approvalMutation.run(() =>
+        client.sendApprovalDecision(workspaceId, sessionId, {
+          approvalId,
+          decision,
+          ...(message !== undefined ? { message } : {}),
+        }));
+    },
+    [client, workspaceId, sessionId, approvalMutation.run],
+  );
+
+  const approve = useCallback(
+    async (approvalId: string, message?: string) => await decide(approvalId, "approve", message),
+    [decide],
+  );
+  const reject = useCallback(
+    async (approvalId: string, message?: string) => await decide(approvalId, "reject", message),
+    [decide],
+  );
+
+  const error = approvalMutation.mutationError ?? interruptMutation.mutationError;
+  const clearError = useCallback(() => {
+    interruptMutation.clearMutationError();
+    approvalMutation.clearMutationError();
+  }, [interruptMutation.clearMutationError, approvalMutation.clearMutationError]);
+
+  return {
+    interrupt,
+    interrupting: interruptMutation.mutating,
+    approve,
+    reject,
+    responding: approvalMutation.mutating,
+    error,
+    clearError,
+  };
+}

package/src/hooks/use-session-events.ts

@@ -0,0 +1,130 @@
+import type { SessionEvent, SessionStatus, StreamConnectionState } from "@opengeni/sdk";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { buildTimeline, sessionStatusFromEvents, type TimelineItem } from "../timeline";
+
+export type SessionEventsConnectionState = StreamConnectionState | "idle" | "ended" | "error";
+
+export type UseSessionEventsOptions = ClientOverride & {
+  /** Resume after this sequence (exclusive). Defaults to 0 = full replay. */
+  after?: number | undefined;
+  /** Pause the stream without unmounting (e.g. hidden tab). Defaults to true. */
+  enabled?: boolean | undefined;
+};
+
+export type UseSessionEventsResult = {
+  /** Replayed + live events, ordered by sequence, no gaps, no duplicates. */
+  events: SessionEvent[];
+  /** Projected, renderable timeline (memoized over `events`). */
+  timeline: TimelineItem[];
+  /** Latest session status observed in the event log, if any. */
+  sessionStatus: SessionStatus | null;
+  connectionState: SessionEventsConnectionState;
+  /** Highest sequence seen so far (0 before the first event). */
+  lastSequence: number;
+  error: Error | null;
+};
+
+/**
+ * Live-stream a session's event log with replay-by-sequence, reconnect, and
+ * batched React updates. The SDK guarantees ordered, gap-free, exactly-once
+ * delivery; this hook accumulates the log and projects it into a timeline.
+ */
+export function useSessionEvents(sessionId: string | null | undefined, options: UseSessionEventsOptions = {}): UseSessionEventsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = options.enabled ?? true;
+  const after = options.after ?? 0;
+
+  const [events, setEvents] = useState<SessionEvent[]>([]);
+  const [connectionState, setConnectionState] = useState<SessionEventsConnectionState>("idle");
+  const [error, setError] = useState<Error | null>(null);
+  const lastSequenceRef = useRef(after);
+  const streamKeyRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    // Reset the accumulated log only when the stream identity changes —
+    // pausing via `enabled: false` keeps the timeline visible.
+    const streamKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${after}`;
+    if (streamKeyRef.current !== streamKey) {
+      streamKeyRef.current = streamKey;
+      setEvents([]);
+      setError(null);
+      lastSequenceRef.current = after;
+    }
+    if (!sessionId || !enabled) {
+      setConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    // Batch yielded events into one React update per flush window so a long
+    // replay (thousands of events) does not render per event.
+    let pending: SessionEvent[] = [];
+    let flushTimer: ReturnType<typeof setTimeout> | null = null;
+    const flush = () => {
+      flushTimer = null;
+      if (pending.length === 0) {
+        return;
+      }
+      const batch = pending;
+      pending = [];
+      // The resume cursor only advances with delivered batches: events still
+      // sitting in `pending` when the stream is torn down are re-fetched on
+      // the next connect instead of being skipped.
+      const lastInBatch = batch[batch.length - 1];
+      if (lastInBatch) {
+        lastSequenceRef.current = lastInBatch.sequence;
+      }
+      setEvents((existing) => [...existing, ...batch]);
+    };
+    const scheduleFlush = () => {
+      flushTimer ??= setTimeout(flush, 16);
+    };
+
+    void (async () => {
+      try {
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: lastSequenceRef.current,
+          signal: controller.signal,
+          onStateChange: (state) => {
+            if (!controller.signal.aborted) {
+              setConnectionState(state);
+            }
+          },
+        });
+        for await (const event of stream) {
+          pending.push(event);
+          scheduleFlush();
+        }
+        if (!controller.signal.aborted) {
+          flush();
+          setConnectionState("ended");
+        }
+      } catch (cause) {
+        if (!controller.signal.aborted) {
+          flush();
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setConnectionState("error");
+        }
+      }
+    })();
+
+    return () => {
+      controller.abort();
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+      }
+    };
+  }, [client, workspaceId, sessionId, after, enabled]);
+
+  const timeline = useMemo(() => buildTimeline(events), [events]);
+  const sessionStatus = useMemo(() => sessionStatusFromEvents(events), [events]);
+
+  return {
+    events,
+    timeline,
+    sessionStatus,
+    connectionState,
+    lastSequence: lastSequenceRef.current,
+    error,
+  };
+}

package/src/hooks/use-session.ts

@@ -0,0 +1,33 @@
+import type { Session } from "@opengeni/sdk";
+import { useCallback } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { usePolledValue } from "./internal";
+
+export type UseSessionOptions = ClientOverride & {
+  /** Re-fetch on an interval (ms). Off by default — pair with `useSessionEvents` for live status. */
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseSessionResult = {
+  session: Session | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+};
+
+/** Fetch one session (with optional polling). */
+export function useSession(sessionId: string | null | undefined, options: UseSessionOptions = {}): UseSessionResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(async () => {
+    if (!sessionId) {
+      return null;
+    }
+    return await client.getSession(workspaceId, sessionId);
+  }, [client, workspaceId, sessionId]);
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: (options.enabled ?? true) && Boolean(sessionId),
+  });
+  return { session: state.data ?? null, loading: state.loading, error: state.error, refresh: state.refresh };
+}