@tangle-network/sandbox-ui 0.3.6 → 0.3.10

package/dist/{chunk-5LV6DZZF.js → chunk-FOQTE67I.js}

@@ -1,6 +1,17 @@
 import {
   parseToolEvent
 } from "./chunk-CCKNIAS7.js";
+import {
+  bumpActiveSessionActivity,
+  registerActiveSession,
+  setActiveSessionAttention,
+  setActiveSessionConnection,
+  setActiveSessionError,
+  setActiveSessionRunning,
+  setForegroundActiveSession,
+  unregisterActiveSession,
+  updateActiveSessionMeta
+} from "./chunk-OEX7NZE3.js";
 
 // src/hooks/use-tool-call-stream.ts
 import { useState, useCallback, useRef } from "react";
@@ -744,8 +755,252 @@ function useSdkSession({
   };
 }
 
+// src/hooks/use-realtime-session.ts
+import { createElement, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef4, useState as useState4 } from "react";
+function parseEvent(message) {
+  try {
+    const parsed = JSON.parse(message);
+    return typeof parsed?.type === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function eventTimestamp(event) {
+  const rootTimestamp = event.timestamp;
+  if (typeof rootTimestamp === "number" && Number.isFinite(rootTimestamp)) {
+    return rootTimestamp;
+  }
+  const raw = event.data?.timestamp ?? event.data?.ts ?? event.data?.time ?? event.data?.eventAt;
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  return null;
+}
+function resolveErrorMessage(event) {
+  const message = event.data?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function updateStoreFromEvent(sessionId, event) {
+  const lastEventAt = eventTimestamp(event) ?? Date.now();
+  bumpActiveSessionActivity(sessionId, { lastEventAt });
+  if (event.type === "session.run.started") {
+    setActiveSessionRunning(sessionId, true, { lastEventAt });
+    return;
+  }
+  if (event.type === "session.run.completed" || event.type === "done" || event.type === "result") {
+    setActiveSessionRunning(sessionId, false, { lastEventAt });
+    return;
+  }
+  if (event.type === "session.attention") {
+    setActiveSessionAttention(sessionId, true, { lastEventAt });
+    return;
+  }
+  if (event.type === "error" || event.type === "session.run.failed") {
+    setActiveSessionError(sessionId, resolveErrorMessage(event) ?? "Session error");
+    return;
+  }
+}
+function useRealtimeSession({
+  sessionId,
+  projectId = null,
+  projectLabel,
+  title,
+  href,
+  metadata,
+  connectUrl,
+  enabled = true,
+  foreground = true,
+  keepRegistered = true,
+  reconnect = true,
+  reconnectIntervalMs = 1500,
+  maxReconnectAttempts = Infinity,
+  transportMode = "websocket",
+  onEvent,
+  onOpen,
+  onClose,
+  onError
+}) {
+  const [connectionState, setConnectionState] = useState4("disconnected");
+  const [lastError, setLastError] = useState4(null);
+  const [reconnectAttempts, setReconnectAttempts] = useState4(0);
+  const socketRef = useRef4(null);
+  const timerRef = useRef4(null);
+  const reconnectAttemptsRef = useRef4(0);
+  const shouldReconnectRef = useRef4(true);
+  const registration = useMemo2(
+    () => ({
+      sessionId,
+      projectId,
+      projectLabel,
+      title,
+      href,
+      metadata
+    }),
+    [href, metadata, projectId, projectLabel, sessionId, title]
+  );
+  useEffect2(() => {
+    if (!sessionId || !keepRegistered) return void 0;
+    registerActiveSession(registration);
+    return () => {
+      unregisterActiveSession(sessionId);
+    };
+  }, [keepRegistered, registration, sessionId]);
+  useEffect2(() => {
+    if (!sessionId || !keepRegistered) return;
+    updateActiveSessionMeta(sessionId, {
+      projectId,
+      projectLabel,
+      title,
+      href,
+      metadata
+    });
+  }, [href, keepRegistered, metadata, projectId, projectLabel, sessionId, title]);
+  useEffect2(() => {
+    if (!sessionId || !foreground) return void 0;
+    setForegroundActiveSession(sessionId);
+    return () => {
+      setForegroundActiveSession(null);
+    };
+  }, [foreground, sessionId]);
+  useEffect2(() => {
+    if (!enabled || !sessionId || !connectUrl || typeof window === "undefined") {
+      setConnectionState("disconnected");
+      if (sessionId) {
+        setActiveSessionConnection(sessionId, {
+          connectionState: "disconnected",
+          reconnectState: "idle",
+          transportMode
+        });
+      }
+      return void 0;
+    }
+    shouldReconnectRef.current = true;
+    const clearReconnectTimer = () => {
+      if (timerRef.current != null) {
+        window.clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+    const connect = () => {
+      clearReconnectTimer();
+      setConnectionState(reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting");
+      setActiveSessionConnection(sessionId, {
+        connectionState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting",
+        reconnectState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "idle",
+        transportMode,
+        lastError: null
+      });
+      const socket = new window.WebSocket(connectUrl);
+      socketRef.current = socket;
+      socket.onopen = () => {
+        reconnectAttemptsRef.current = 0;
+        setReconnectAttempts(0);
+        setLastError(null);
+        setConnectionState("connected");
+        registerActiveSession(registration);
+        setActiveSessionConnection(sessionId, {
+          connectionState: "connected",
+          reconnectState: "idle",
+          transportMode,
+          lastError: null,
+          lastEventAt: Date.now()
+        });
+        onOpen?.();
+      };
+      socket.onmessage = (message) => {
+        const event = parseEvent(message.data);
+        if (!event) return;
+        registerActiveSession(registration);
+        updateStoreFromEvent(sessionId, event);
+        onEvent?.(event);
+      };
+      socket.onerror = () => {
+        const nextError = "Realtime session connection error";
+        setLastError(nextError);
+        setConnectionState("error");
+        setActiveSessionConnection(sessionId, {
+          connectionState: "error",
+          reconnectState: reconnect ? "reconnecting" : "failed",
+          transportMode,
+          lastError: nextError
+        });
+        onError?.(new Error(nextError));
+      };
+      socket.onclose = () => {
+        socketRef.current = null;
+        onClose?.();
+        if (!shouldReconnectRef.current || !reconnect) {
+          setConnectionState("disconnected");
+          setActiveSessionConnection(sessionId, {
+            connectionState: "disconnected",
+            reconnectState: "idle",
+            transportMode
+          });
+          return;
+        }
+        reconnectAttemptsRef.current += 1;
+        setReconnectAttempts(reconnectAttemptsRef.current);
+        if (reconnectAttemptsRef.current > maxReconnectAttempts) {
+          setConnectionState("error");
+          setActiveSessionConnection(sessionId, {
+            connectionState: "error",
+            reconnectState: "failed",
+            transportMode,
+            lastError: "Unable to reconnect to realtime session"
+          });
+          return;
+        }
+        setConnectionState("reconnecting");
+        timerRef.current = window.setTimeout(connect, reconnectIntervalMs);
+      };
+    };
+    connect();
+    return () => {
+      shouldReconnectRef.current = false;
+      clearReconnectTimer();
+      const socket = socketRef.current;
+      socketRef.current = null;
+      if (socket && socket.readyState < WebSocket.CLOSING) {
+        socket.close();
+      }
+    };
+  }, [
+    connectUrl,
+    enabled,
+    maxReconnectAttempts,
+    onClose,
+    onError,
+    onEvent,
+    onOpen,
+    reconnect,
+    reconnectIntervalMs,
+    registration,
+    sessionId,
+    transportMode
+  ]);
+  return {
+    connectionState,
+    lastError,
+    reconnectAttempts,
+    isConnected: connectionState === "connected"
+  };
+}
+function RealtimeSessionRegistryItem(props) {
+  useRealtimeSession({
+    ...props,
+    foreground: props.foreground ?? false
+  });
+  return null;
+}
+function RealtimeSessionRegistry({ sessions }) {
+  return sessions.map(
+    (session) => createElement(RealtimeSessionRegistryItem, {
+      key: session.key ?? session.sessionId,
+      ...session
+    })
+  );
+}
+
 // src/hooks/use-session-stream.ts
-import { useCallback as useCallback4, useEffect as useEffect2, useRef as useRef4, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef5, useState as useState5 } from "react";
 var _insertionCounter = 0;
 function mapApiMessage(msg) {
   const created = msg.info.timestamp ? new Date(msg.info.timestamp).getTime() : Date.now();
@@ -795,13 +1050,13 @@ function useSessionStream({
   sessionId,
   enabled = true
 }) {
-  const [messages, setMessages] = useState4([]);
-  const [partMap, setPartMap] = useState4({});
-  const [isStreaming, setIsStreaming] = useState4(false);
-  const [error, setError] = useState4(null);
-  const [connected, setConnected] = useState4(false);
-  const abortRef = useRef4(null);
-  const streamingMsgIdRef = useRef4(null);
+  const [messages, setMessages] = useState5([]);
+  const [partMap, setPartMap] = useState5({});
+  const [isStreaming, setIsStreaming] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [connected, setConnected] = useState5(false);
+  const abortRef = useRef5(null);
+  const streamingMsgIdRef = useRef5(null);
   const refetch = useCallback4(async () => {
     if (!token || !sessionId || !apiUrl) return;
     try {
@@ -988,7 +1243,7 @@ function useSessionStream({
       setError(msg);
     }
   }, [apiUrl, token, sessionId]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!enabled || !token || !sessionId) return;
     refetch();
     connectSSE();
@@ -1001,12 +1256,12 @@ function useSessionStream({
 }
 
 // src/hooks/use-dropdown-menu.ts
-import { useEffect as useEffect3, useRef as useRef5, useState as useState5 } from "react";
+import { useEffect as useEffect4, useRef as useRef6, useState as useState6 } from "react";
 function useDropdownMenu(options) {
   const closeOnEsc = options?.closeOnEsc ?? true;
-  const [open, setOpen] = useState5(false);
-  const ref = useRef5(null);
-  useEffect3(() => {
+  const [open, setOpen] = useState6(false);
+  const ref = useRef6(null);
+  useEffect4(() => {
     function handleClick(e) {
       if (ref.current && !ref.current.contains(e.target)) {
         setOpen(false);
@@ -1017,7 +1272,7 @@ function useDropdownMenu(options) {
     }
     return () => document.removeEventListener("mousedown", handleClick);
   }, [open]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!open || !closeOnEsc) return;
     function handleKey(e) {
       if (e.key === "Escape") setOpen(false);
@@ -1035,7 +1290,7 @@ function useDropdownMenu(options) {
 }
 
 // src/hooks/use-sidecar-auth.ts
-import { useState as useState6, useCallback as useCallback5, useEffect as useEffect4, useRef as useRef6 } from "react";
+import { useState as useState7, useCallback as useCallback5, useEffect as useEffect5, useRef as useRef7 } from "react";
 function storageKey(resourceId, apiUrl) {
   return `sidecar_session_${resourceId}__${apiUrl}`;
 }
@@ -1067,11 +1322,11 @@ function clearSession(resourceId, apiUrl) {
 }
 function useSidecarAuth({ resourceId, apiUrl, signMessage }) {
   const cached = loadSession(resourceId, apiUrl);
-  const [token, setToken] = useState6(cached?.token ?? null);
-  const [expiresAt, setExpiresAt] = useState6(cached?.expiresAt ?? 0);
-  const [isAuthenticating, setIsAuthenticating] = useState6(false);
-  const [error, setError] = useState6(null);
-  const refreshTimerRef = useRef6(void 0);
+  const [token, setToken] = useState7(cached?.token ?? null);
+  const [expiresAt, setExpiresAt] = useState7(cached?.expiresAt ?? 0);
+  const [isAuthenticating, setIsAuthenticating] = useState7(false);
+  const [error, setError] = useState7(null);
+  const refreshTimerRef = useRef7(void 0);
   const clearCachedToken = useCallback5(() => {
     setToken(null);
     setExpiresAt(0);
@@ -1112,7 +1367,7 @@ function useSidecarAuth({ resourceId, apiUrl, signMessage }) {
       setIsAuthenticating(false);
     }
   }, [resourceId, apiUrl, signMessage, clearCachedToken]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (refreshTimerRef.current) {
       clearTimeout(refreshTimerRef.current);
     }
@@ -1147,6 +1402,8 @@ export {
   useToolCallStream,
   useSSEStream,
   useSdkSession,
+  useRealtimeSession,
+  RealtimeSessionRegistry,
   useSessionStream,
   useDropdownMenu,
   useSidecarAuth