@backbay/glia 0.2.0-alpha.6 → 0.2.0-alpha.8

package/dist/hooks/index.js

@@ -1,8 +1,943 @@
-export { IntensityProvider, useIntensity, useIntensityContext } from '../chunk-4SRFO5W3.js';
-export { subscribeToRunEvents, useRunStream } from '../chunk-Z2S54IZX.js';
-export { useAgentRun, usePlaySession, useSync } from '../chunk-YIUG7IJK.js';
-import '../chunk-Q2XDMV7U.js';
-import '../chunk-OBZD2M3C.js';
-import '../chunk-TM6AOUSD.js';
+import { createContext, useState, useRef, useCallback, useEffect, useMemo, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/hooks/useSync.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    return encoded === void 0 ? "null" : encoded;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
+}
+function hashString(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(36);
+}
+function hashData(value) {
+  return hashString(stableStringify(value));
+}
+function normalizeStoredData(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  if ("data" in record && typeof record.lastModifiedAt === "number" && typeof record.lastSyncedAt === "number" && typeof record.lastSyncedHash === "string") {
+    return record;
+  }
+  if ("data" in record && typeof record.timestamp === "number" && typeof record.version === "number") {
+    const legacy = record;
+    const syncedHash = hashData(legacy.data);
+    return {
+      data: legacy.data,
+      lastModifiedAt: legacy.timestamp,
+      lastSyncedAt: legacy.timestamp,
+      lastSyncedHash: syncedHash
+    };
+  }
+  return null;
+}
+function getStoredData(key) {
+  try {
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return normalizeStoredData(parsed);
+  } catch {
+    return null;
+  }
+}
+function setStoredData(key, record) {
+  localStorage.setItem(key, JSON.stringify(record));
+}
+function useSync({
+  key,
+  endpoint,
+  debounce = 2e3,
+  initialData,
+  fetcher,
+  saver,
+  onConflict,
+  onError,
+  onSync
+}) {
+  const [data, setDataState] = useState(initialData ?? null);
+  const [status, setStatus] = useState("synced");
+  const [pendingChanges, setPendingChanges] = useState(0);
+  const [lastSyncedAt, setLastSyncedAt] = useState(null);
+  const [conflict, setConflict] = useState(null);
+  const [isLoaded, setIsLoaded] = useState(false);
+  const debounceTimerRef = useRef(null);
+  const isSavingRef = useRef(false);
+  const doFetch = useCallback(
+    async (url) => {
+      if (fetcher) return fetcher(url);
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response.json();
+    },
+    [fetcher]
+  );
+  const doSave = useCallback(
+    async (url, payload) => {
+      if (saver) return saver(url, payload);
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response.json();
+    },
+    [saver]
+  );
+  useEffect(() => {
+    const loadInitial = async () => {
+      const stored = getStoredData(key);
+      if (stored) {
+        setDataState(stored.data);
+        const storedSyncedAt = stored.lastSyncedAt > 0 ? stored.lastSyncedAt : null;
+        setLastSyncedAt(storedSyncedAt);
+        const hasLocalChanges = stored.lastModifiedAt > stored.lastSyncedAt;
+        if (hasLocalChanges) {
+          setStatus("pending");
+          setPendingChanges((c) => Math.max(c, 1));
+        }
+      }
+      try {
+        const serverData = await doFetch(endpoint);
+        const remoteTimestamp = Date.now();
+        const remoteHash = hashData(serverData);
+        if (stored) {
+          const hasLocalChanges = stored.lastModifiedAt > stored.lastSyncedAt;
+          const baselineHash = stored.lastSyncedHash || hashData(stored.data);
+          const remoteChangedSinceSync = remoteHash !== baselineHash;
+          if (hasLocalChanges && remoteChangedSinceSync) {
+            const localConflict = {
+              local: stored.data,
+              remote: serverData,
+              localTimestamp: stored.lastModifiedAt,
+              remoteTimestamp
+            };
+            setConflict(localConflict);
+            setStatus("conflict");
+            onConflict?.(localConflict);
+          } else if (!hasLocalChanges) {
+            setDataState(serverData);
+            setStoredData(key, {
+              data: serverData,
+              lastModifiedAt: remoteTimestamp,
+              lastSyncedAt: remoteTimestamp,
+              lastSyncedHash: remoteHash
+            });
+            setLastSyncedAt(remoteTimestamp);
+            setPendingChanges(0);
+            setStatus("synced");
+          } else {
+            setStatus("pending");
+          }
+        } else {
+          setDataState(serverData);
+          setStoredData(key, {
+            data: serverData,
+            lastModifiedAt: remoteTimestamp,
+            lastSyncedAt: remoteTimestamp,
+            lastSyncedHash: remoteHash
+          });
+          setLastSyncedAt(remoteTimestamp);
+          setPendingChanges(0);
+          setStatus("synced");
+        }
+      } catch (error) {
+        setStatus("offline");
+        if (error instanceof Error) {
+          onError?.(error);
+        }
+      }
+      setIsLoaded(true);
+    };
+    loadInitial();
+  }, [key, endpoint, doFetch, onConflict, onError]);
+  const saveToServer = useCallback(async (payload) => {
+    const dataToSave = payload ?? data;
+    if (isSavingRef.current || dataToSave === null) return;
+    isSavingRef.current = true;
+    try {
+      setStatus("pending");
+      const serverData = await doSave(endpoint, dataToSave);
+      const syncedAt = Date.now();
+      const syncedHash = hashData(serverData);
+      setDataState(serverData);
+      setStoredData(key, {
+        data: serverData,
+        lastModifiedAt: syncedAt,
+        lastSyncedAt: syncedAt,
+        lastSyncedHash: syncedHash
+      });
+      setLastSyncedAt(syncedAt);
+      setPendingChanges(0);
+      setStatus("synced");
+      onSync?.(serverData);
+    } catch (error) {
+      setStatus("offline");
+      if (error instanceof Error) {
+        onError?.(error);
+      }
+    } finally {
+      isSavingRef.current = false;
+    }
+  }, [data, endpoint, key, doSave, onSync, onError]);
+  const setData = useCallback(
+    (updater) => {
+      setDataState((prev) => {
+        const newData = typeof updater === "function" ? updater(prev) : updater;
+        const previousStored = getStoredData(key);
+        const now = Date.now();
+        setStoredData(key, {
+          data: newData,
+          lastModifiedAt: now,
+          lastSyncedAt: previousStored?.lastSyncedAt ?? 0,
+          lastSyncedHash: previousStored?.lastSyncedHash ?? ""
+        });
+        setPendingChanges((c) => c + 1);
+        setStatus("pending");
+        if (debounceTimerRef.current) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout(() => {
+          saveToServer();
+        }, debounce);
+        return newData;
+      });
+    },
+    [key, debounce, saveToServer]
+  );
+  const forceSave = useCallback(async () => {
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+      debounceTimerRef.current = null;
+    }
+    await saveToServer();
+  }, [saveToServer]);
+  const refresh = useCallback(async () => {
+    try {
+      const serverData = await doFetch(endpoint);
+      const syncedAt = Date.now();
+      const syncedHash = hashData(serverData);
+      setDataState(serverData);
+      setStoredData(key, {
+        data: serverData,
+        lastModifiedAt: syncedAt,
+        lastSyncedAt: syncedAt,
+        lastSyncedHash: syncedHash
+      });
+      setLastSyncedAt(syncedAt);
+      setPendingChanges(0);
+      setConflict(null);
+      setStatus("synced");
+    } catch (error) {
+      setStatus("offline");
+      if (error instanceof Error) {
+        onError?.(error);
+      }
+    }
+  }, [endpoint, key, doFetch, onError]);
+  const resolveConflict = useCallback(
+    async (resolution) => {
+      if (!conflict) return;
+      switch (resolution) {
+        case "keep_local":
+          setDataState(conflict.local);
+          setConflict(null);
+          setStatus("pending");
+          setPendingChanges((c) => Math.max(c, 1));
+          await saveToServer(conflict.local);
+          break;
+        case "use_remote": {
+          const remoteHash = hashData(conflict.remote);
+          setDataState(conflict.remote);
+          setStoredData(key, {
+            data: conflict.remote,
+            lastModifiedAt: conflict.remoteTimestamp,
+            lastSyncedAt: conflict.remoteTimestamp,
+            lastSyncedHash: remoteHash
+          });
+          setLastSyncedAt(conflict.remoteTimestamp);
+          setPendingChanges(0);
+          setConflict(null);
+          setStatus("synced");
+          break;
+        }
+        case "create_copy":
+          setDataState(conflict.local);
+          setConflict(null);
+          setStatus("pending");
+          setPendingChanges((c) => Math.max(c, 1));
+          await saveToServer(conflict.local);
+          break;
+      }
+    },
+    [conflict, key, saveToServer]
+  );
+  useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+    };
+  }, []);
+  return {
+    data,
+    setData,
+    status,
+    pendingChanges,
+    lastSyncedAt,
+    conflict,
+    resolveConflict,
+    forceSave,
+    refresh,
+    isLoaded
+  };
+}
+var BBContext = createContext(null);
+function useBBContext() {
+  const context = useContext(BBContext);
+  if (!context) {
+    throw new Error("useBBContext must be used within a BBProvider");
+  }
+  return context;
+}
+
+// src/hooks/useAgentRun.ts
+function useAgentRun(options = {}) {
+  const { onStart, onComplete, onError, onCancel } = options;
+  const { config, addRun, updateRun, getAgent } = useBBContext();
+  const [run, setRun] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [output, setOutput] = useState(null);
+  const [error, setError] = useState(null);
+  const [cost, setCost] = useState(null);
+  const [latency, setLatency] = useState(null);
+  const abortControllerRef = useRef(null);
+  const start = useCallback(
+    async (agentId, prompt, context) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+      const startedAt = Date.now();
+      const newRun = {
+        id: runId,
+        agentId,
+        prompt,
+        context,
+        status: "running",
+        startedAt
+      };
+      setRun(newRun);
+      setStatus("running");
+      setOutput(null);
+      setError(null);
+      setCost(null);
+      setLatency(null);
+      addRun(newRun);
+      onStart?.(newRun);
+      try {
+        const response = await fetch(`${config.apiBaseUrl}/runs`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers
+          },
+          body: JSON.stringify({
+            agentId,
+            prompt,
+            context
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const result = await response.json();
+        const completedAt = Date.now();
+        const runLatency = completedAt - startedAt;
+        const agent = getAgent(agentId);
+        const runCost = result.cost ?? agent?.costPerRun ?? 0;
+        const completedRun = {
+          ...newRun,
+          status: "completed",
+          output: result.output,
+          cost: runCost,
+          tokenCount: result.tokenCount,
+          latencyMs: runLatency,
+          completedAt
+        };
+        setRun(completedRun);
+        setStatus("completed");
+        setOutput(result.output);
+        setCost(runCost);
+        setLatency(runLatency);
+        updateRun(runId, completedRun);
+        onComplete?.(completedRun);
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          const cancelledRun = {
+            ...newRun,
+            status: "cancelled",
+            completedAt: Date.now()
+          };
+          setRun(cancelledRun);
+          setStatus("cancelled");
+          updateRun(runId, cancelledRun);
+          onCancel?.(cancelledRun);
+          return;
+        }
+        const errorMessage = err instanceof Error ? err.message : "Unknown error";
+        const failedRun = {
+          ...newRun,
+          status: "failed",
+          error: errorMessage,
+          completedAt: Date.now()
+        };
+        setRun(failedRun);
+        setStatus("failed");
+        setError(errorMessage);
+        updateRun(runId, failedRun);
+        onError?.(failedRun, err instanceof Error ? err : new Error(errorMessage));
+      } finally {
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [config, addRun, updateRun, getAgent, onStart, onComplete, onError, onCancel]
+  );
+  const cancel = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  return {
+    run,
+    status,
+    output,
+    error,
+    cost,
+    latency,
+    start,
+    cancel,
+    isRunning: status === "running"
+  };
+}
+function useRunStream(runId, options = {}) {
+  const { pollInterval = 4e3, preferPolling = false, onEvent, onComplete, onError } = options;
+  const { config } = useBBContext();
+  const [events, setEvents] = useState([]);
+  const [latestEvent, setLatestEvent] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [isConnected, setIsConnected] = useState(false);
+  const [run, setRun] = useState(null);
+  const eventSourceRef = useRef(null);
+  const pollingIntervalRef = useRef(null);
+  const isActiveRef = useRef(true);
+  const handleEvent = useCallback(
+    (event) => {
+      if (!isActiveRef.current) return;
+      setEvents((prev) => [...prev, event]);
+      setLatestEvent(event);
+      onEvent?.(event);
+      if (event.data?.status) {
+        setStatus(event.data.status);
+      }
+      if (event.type === "completed" || event.type === "failed" || event.type === "cancelled") {
+        const finalStatus = event.type === "completed" ? "completed" : event.type === "failed" ? "failed" : "cancelled";
+        setStatus(finalStatus);
+        if (event.data?.run) {
+          setRun(event.data.run);
+          if (event.type === "completed") {
+            onComplete?.(event.data.run);
+          }
+        }
+      }
+    },
+    [onEvent, onComplete]
+  );
+  const setupEventSource = useCallback(() => {
+    if (!runId || preferPolling) return;
+    const url = `${config.apiBaseUrl}/runs/${runId}/events`;
+    const eventSource = new EventSource(url);
+    eventSource.onopen = () => {
+      setIsConnected(true);
+      handleEvent({
+        type: "connected",
+        runId,
+        timestamp: Date.now()
+      });
+    };
+    eventSource.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        handleEvent({
+          type: data.type ?? "status",
+          runId,
+          timestamp: Date.now(),
+          data
+        });
+      } catch (err) {
+        console.error("Failed to parse event:", err);
+      }
+    };
+    eventSource.onerror = () => {
+      setIsConnected(false);
+      startPolling();
+    };
+    eventSourceRef.current = eventSource;
+  }, [runId, config.apiBaseUrl, preferPolling, handleEvent]);
+  const startPolling = useCallback(() => {
+    if (!runId || pollingIntervalRef.current) return;
+    const poll = async () => {
+      if (!isActiveRef.current || !runId) return;
+      try {
+        const response = await fetch(`${config.apiBaseUrl}/runs/${runId}`, {
+          headers: config.headers
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        handleEvent({
+          type: "status",
+          runId,
+          timestamp: Date.now(),
+          data: {
+            status: data.status,
+            output: data.output,
+            run: data
+          }
+        });
+        if (data.status === "completed" || data.status === "failed" || data.status === "cancelled") {
+          stopPolling();
+          handleEvent({
+            type: data.status,
+            runId,
+            timestamp: Date.now(),
+            data: { run: data }
+          });
+        }
+      } catch (err) {
+        if (err instanceof Error) {
+          onError?.(err);
+        }
+      }
+    };
+    poll();
+    pollingIntervalRef.current = setInterval(poll, pollInterval);
+  }, [runId, config, pollInterval, handleEvent, onError]);
+  const stopPolling = useCallback(() => {
+    if (pollingIntervalRef.current) {
+      clearInterval(pollingIntervalRef.current);
+      pollingIntervalRef.current = null;
+    }
+  }, []);
+  const disconnect = useCallback(() => {
+    isActiveRef.current = false;
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+      eventSourceRef.current = null;
+    }
+    stopPolling();
+    setIsConnected(false);
+  }, [stopPolling]);
+  const reconnect = useCallback(() => {
+    disconnect();
+    isActiveRef.current = true;
+    setEvents([]);
+    setLatestEvent(null);
+    setStatus("idle");
+    if (preferPolling) {
+      startPolling();
+    } else {
+      setupEventSource();
+    }
+  }, [disconnect, preferPolling, startPolling, setupEventSource]);
+  useEffect(() => {
+    if (!runId) {
+      disconnect();
+      return;
+    }
+    isActiveRef.current = true;
+    setEvents([]);
+    setLatestEvent(null);
+    setStatus("running");
+    if (preferPolling) {
+      startPolling();
+    } else {
+      setupEventSource();
+      setTimeout(() => {
+        if (isActiveRef.current && !isConnected) {
+          startPolling();
+        }
+      }, 2e3);
+    }
+    return () => {
+      disconnect();
+    };
+  }, [runId]);
+  return {
+    events,
+    latestEvent,
+    status,
+    isConnected,
+    run,
+    disconnect,
+    reconnect
+  };
+}
+function subscribeToRunEvents(apiBaseUrl, runId, callback, options = {}) {
+  const url = `${apiBaseUrl}/runs/${runId}/events`;
+  const eventSource = new EventSource(url);
+  eventSource.onopen = () => {
+    callback({
+      type: "connected",
+      runId,
+      timestamp: Date.now()
+    });
+  };
+  eventSource.onmessage = (e) => {
+    try {
+      const data = JSON.parse(e.data);
+      callback({
+        type: data.type ?? "status",
+        runId,
+        timestamp: Date.now(),
+        data
+      });
+    } catch (err) {
+      console.error("Failed to parse event:", err);
+    }
+  };
+  eventSource.onerror = () => {
+  };
+  return () => eventSource.close();
+}
+var DEFAULT_SMOOTHING = 0.3;
+var DEFAULT_UPDATE_INTERVAL = 50;
+function useIntensity(options = {}) {
+  const {
+    smoothing = DEFAULT_SMOOTHING,
+    updateInterval = DEFAULT_UPDATE_INTERVAL,
+    sources = ["activeRuns"],
+    customIntensity: initialCustom = 0
+  } = options;
+  const { activeRuns, syncStatus } = useBBContext();
+  const [customIntensity, setCustomIntensity] = useState(initialCustom);
+  const [values, setValues] = useState({
+    intensity: 0,
+    presence: 0,
+    activity: 0,
+    breathing: 0
+  });
+  const targetRef = useRef({
+    intensity: 0,
+    presence: 0,
+    activity: 0,
+    breathing: 0
+  });
+  const animationFrameRef = useRef(null);
+  const lastUpdateRef = useRef(Date.now());
+  const calculateTarget = useCallback(() => {
+    let runIntensity = 0;
+    let syncIntensity = 0;
+    let custom = 0;
+    if (sources.includes("activeRuns")) {
+      runIntensity = Math.min(activeRuns.length / 3, 1);
+    }
+    if (sources.includes("pendingSync")) {
+      syncIntensity = syncStatus === "pending" ? 0.5 : syncStatus === "conflict" ? 0.8 : 0;
+    }
+    if (sources.includes("custom")) {
+      custom = customIntensity;
+    }
+    const combinedIntensity = Math.min(
+      Math.max(runIntensity, syncIntensity, custom),
+      1
+    );
+    const presence = combinedIntensity > 0 ? Math.min(combinedIntensity + 0.3, 1) : 0;
+    const activity = combinedIntensity;
+    const breathing = combinedIntensity > 0.2 ? Math.min(combinedIntensity * 1.2, 1) : 0;
+    targetRef.current = {
+      intensity: combinedIntensity,
+      presence,
+      activity,
+      breathing
+    };
+  }, [activeRuns.length, syncStatus, customIntensity, sources]);
+  useEffect(() => {
+    const animate = () => {
+      const now = Date.now();
+      const delta = (now - lastUpdateRef.current) / 1e3;
+      lastUpdateRef.current = now;
+      calculateTarget();
+      const lerpFactor = 1 - Math.pow(1 - smoothing, delta * 60);
+      setValues((prev) => ({
+        intensity: prev.intensity + (targetRef.current.intensity - prev.intensity) * lerpFactor,
+        presence: prev.presence + (targetRef.current.presence - prev.presence) * lerpFactor,
+        activity: prev.activity + (targetRef.current.activity - prev.activity) * lerpFactor,
+        breathing: prev.breathing + (targetRef.current.breathing - prev.breathing) * lerpFactor
+      }));
+      animationFrameRef.current = requestAnimationFrame(animate);
+    };
+    animationFrameRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+    };
+  }, [calculateTarget, smoothing]);
+  const cssVars = useMemo(
+    () => ({
+      "--glia-intensity": values.intensity.toFixed(3),
+      "--glia-intensity-presence": values.presence.toFixed(3),
+      "--glia-intensity-activity": values.activity.toFixed(3),
+      "--glia-intensity-breathing": values.breathing.toFixed(3)
+    }),
+    [values]
+  );
+  const cssVarsString = useMemo(
+    () => Object.entries(cssVars).map(([key, value]) => `${key}: ${value}`).join("; "),
+    [cssVars]
+  );
+  return {
+    ...values,
+    setCustomIntensity,
+    cssVars,
+    cssVarsString
+  };
+}
+var IntensityContext = createContext(null);
+function IntensityProvider({ children, options }) {
+  const intensity = useIntensity(options);
+  useEffect(() => {
+    const root = document.documentElement;
+    root.style.setProperty("--glia-intensity", intensity.intensity.toFixed(3));
+    root.style.setProperty("--glia-intensity-presence", intensity.presence.toFixed(3));
+    root.style.setProperty("--glia-intensity-activity", intensity.activity.toFixed(3));
+    root.style.setProperty("--glia-intensity-breathing", intensity.breathing.toFixed(3));
+  }, [intensity]);
+  return /* @__PURE__ */ jsx(IntensityContext.Provider, { value: intensity, children });
+}
+function useIntensityContext() {
+  const context = useContext(IntensityContext);
+  if (!context) {
+    throw new Error("useIntensityContext must be used within an IntensityProvider");
+  }
+  return context;
+}
+function usePlaySession({
+  adapter,
+  autoConnect = false,
+  timeout = 3e4,
+  onConnect,
+  onDisconnect,
+  onRpcResult,
+  onError
+}) {
+  const { config } = useBBContext();
+  const [session, setSession] = useState(null);
+  const [status, setStatus] = useState("disconnected");
+  const [videoTrack, setVideoTrack] = useState(null);
+  const [audioTrack, setAudioTrack] = useState(null);
+  const [error, setError] = useState(null);
+  const wsRef = useRef(null);
+  const rpcIdRef = useRef(0);
+  const pendingCallsRef = useRef(/* @__PURE__ */ new Map());
+  const connect = useCallback(
+    async (options) => {
+      if (status === "connecting" || status === "connected") return;
+      setStatus("connecting");
+      setError(null);
+      const connectTimeout = options?.timeout ?? timeout;
+      try {
+        const response = await fetch(`${config.apiBaseUrl}/play-sessions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers
+          },
+          body: JSON.stringify({ adapter })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const sessionData = await response.json();
+        const newSession = {
+          id: sessionData.id,
+          adapter,
+          capabilityToken: sessionData.capabilityToken,
+          createdAt: Date.now(),
+          expiresAt: sessionData.expiresAt,
+          livekitUrl: sessionData.livekitUrl,
+          livekitToken: sessionData.livekitToken
+        };
+        setSession(newSession);
+        const wsUrl = sessionData.wsUrl ?? `${config.apiBaseUrl.replace("http", "ws")}/play-sessions/${newSession.id}/ws`;
+        const ws = new WebSocket(wsUrl);
+        wsRef.current = ws;
+        await new Promise((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            ws.close();
+            reject(new Error("Connection timeout"));
+          }, connectTimeout);
+          ws.onopen = () => {
+            clearTimeout(timeoutId);
+            resolve();
+          };
+          ws.onerror = () => {
+            clearTimeout(timeoutId);
+            reject(new Error("WebSocket connection failed"));
+          };
+        });
+        ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            if ("id" in message && pendingCallsRef.current.has(message.id)) {
+              const pending = pendingCallsRef.current.get(message.id);
+              pendingCallsRef.current.delete(message.id);
+              pending.resolve(message);
+              onRpcResult?.(message);
+            }
+          } catch {
+          }
+        };
+        ws.onclose = () => {
+          setStatus("disconnected");
+          setSession(null);
+          wsRef.current = null;
+          onDisconnect?.();
+        };
+        ws.onerror = () => {
+          setError("WebSocket error");
+          onError?.(new Error("WebSocket error"));
+        };
+        if (newSession.livekitUrl && newSession.livekitToken) {
+        }
+        setStatus("connected");
+        onConnect?.(newSession);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Connection failed";
+        setStatus("error");
+        setError(errorMessage);
+        onError?.(err instanceof Error ? err : new Error(errorMessage));
+      }
+    },
+    [adapter, config, status, timeout, onConnect, onDisconnect, onRpcResult, onError]
+  );
+  const disconnect = useCallback(async () => {
+    if (wsRef.current) {
+      wsRef.current.close();
+      wsRef.current = null;
+    }
+    if (session) {
+      try {
+        await fetch(`${config.apiBaseUrl}/play-sessions/${session.id}`, {
+          method: "DELETE",
+          headers: config.headers
+        });
+      } catch {
+      }
+    }
+    setSession(null);
+    setStatus("disconnected");
+    setVideoTrack(null);
+    setAudioTrack(null);
+    onDisconnect?.();
+  }, [session, config, onDisconnect]);
+  const call = useCallback(
+    (method, params) => {
+      return new Promise((resolve, reject) => {
+        if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) {
+          reject(new Error("Not connected"));
+          return;
+        }
+        const id = ++rpcIdRef.current;
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params: params ?? {}
+        };
+        pendingCallsRef.current.set(id, {
+          resolve,
+          reject
+        });
+        wsRef.current.send(JSON.stringify(request));
+        setTimeout(() => {
+          if (pendingCallsRef.current.has(id)) {
+            pendingCallsRef.current.delete(id);
+            reject(new Error("RPC call timeout"));
+          }
+        }, 3e4);
+      });
+    },
+    []
+  );
+  const observe = useCallback(
+    async (key) => {
+      const response = await call(`observe.${key}`);
+      if (response.error) {
+        throw new Error(response.error.message);
+      }
+      return response.result;
+    },
+    [call]
+  );
+  const act = useCallback(
+    async (action, params) => {
+      const response = await call(`act.${action}`, params);
+      if (response.error) {
+        throw new Error(response.error.message);
+      }
+      return response.result;
+    },
+    [call]
+  );
+  useEffect(() => {
+    if (autoConnect) {
+      connect();
+    }
+  }, [autoConnect]);
+  useEffect(() => {
+    return () => {
+      if (wsRef.current) {
+        wsRef.current.close();
+      }
+    };
+  }, []);
+  return {
+    session,
+    status,
+    videoTrack,
+    audioTrack,
+    call,
+    observe,
+    act,
+    connect,
+    disconnect,
+    isConnected: status === "connected",
+    error
+  };
+}
+
+export { IntensityProvider, subscribeToRunEvents, useAgentRun, useIntensity, useIntensityContext, usePlaySession, useRunStream, useSync };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map