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

package/dist/chunk-YIUG7IJK.js

@@ -1,628 +0,0 @@
-import { useBBContext } from './chunk-Q2XDMV7U.js';
-import { useState, useRef, useCallback, useEffect } from 'react';
-
-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
-  };
-}
-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 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 { useAgentRun, usePlaySession, useSync };
-//# sourceMappingURL=chunk-YIUG7IJK.js.map
-//# sourceMappingURL=chunk-YIUG7IJK.js.map