@athenaintel/react 0.57.2 → 0.60.0

package/dist/agent-runtime/src/quota-safe-local-storage-session.js

@@ -1,14 +1,55 @@
 import { resource, useResource } from "@assistant-ui/tap";
-import { KeyValueSessionStorage } from "statewire/storage";
-import { useRef, useMemo, useEffect, useCallback } from "react";
+import { sessionNamespace, KeyValueSessionStorage } from "statewire/storage";
+import { useRef, useMemo, useCallback, useEffect, useState } from "react";
 import { isSameSessionLaneScope } from "./session-lane-scope.js";
-import { DEEP_AGENT_STATEWIRE_PROTOCOL } from "./statewire-transport.js";
+import { upgradeLegacyRunCommand, LEGACY_RUN_SEND_BEHAVIORS } from "./run-send.js";
+import { DEEP_AGENT_STATEWIRE_PROTOCOL, DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION } from "./statewire-transport.js";
 const SESSION_PREFIX = "aui:statewire-session:";
 const SESSION_LOCK_PREFIX = "aui:statewire-session-lock:";
 const SESSION_ACTIVE_PREFIX = "aui:statewire-session-active:";
+const TAB_LOCK_PREFIX = "statewire-tab:";
+const NOTIFY_LOCK_PREFIX = "statewire-notify:";
 const DAY_MS = 24 * 60 * 60 * 1e3;
-const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3]);
+const LOCAL_SESSION_RECORD_BYTES = 512 * 1024;
+const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 6]);
 const browserGlobals = globalThis;
+function sessionPrincipal(subject) {
+  return `user:${subject}`;
+}
+function localStorageSessionKey({
+  namespace,
+  principal,
+  threadId
+}) {
+  return sessionNamespace(namespace, principal) + threadId;
+}
+function adoptUnscopedLocalStorageSessions({
+  namespace,
+  principal,
+  unscopedPrefix,
+  threadId,
+  storage = browserGlobals.localStorage
+}) {
+  if (!storage) return 0;
+  const from = SESSION_PREFIX + unscopedPrefix;
+  let moved = 0;
+  try {
+    const keys = threadId === void 0 ? Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter(
+      (key) => (key == null ? void 0 : key.startsWith(from)) === true
+    ) : [from + threadId];
+    for (const key of keys) {
+      const raw = storage.getItem(key);
+      if (raw === null) continue;
+      const target = SESSION_PREFIX + localStorageSessionKey({ namespace, principal, threadId: key.slice(from.length) });
+      if (target === key || storage.getItem(target) !== null) continue;
+      storage.setItem(target, raw);
+      storage.removeItem(key);
+      moved += 1;
+    }
+  } catch {
+  }
+  return moved;
+}
 function readPersistedFailedSendStamps(sessionKey) {
   const storage = browserGlobals.localStorage;
   if (!storage) return null;
@@ -28,9 +69,12 @@ function readFailedSendStampsFromRecord(record) {
   const lanes = record.lanes && typeof record.lanes === "object" ? record.lanes : {};
   const failed = [
     ...Array.isArray(record.failed) ? record.failed : [],
-    ...Object.values(lanes).flatMap(
-      (lane) => Array.isArray(lane == null ? void 0 : lane.failed) ? lane.failed : []
-    )
+    ...Object.values(lanes).flatMap((lane) => [
+      ...Array.isArray(lane == null ? void 0 : lane.failed) ? lane.failed : [],
+      ...Array.isArray(lane == null ? void 0 : lane.inbox) ? lane.inbox.filter(
+        (entry) => (entry == null ? void 0 : entry.failure) !== void 0
+      ) : []
+    ])
   ];
   for (const entry of failed) {
     const failed2 = entry;
@@ -60,42 +104,73 @@ const replayableOnCurrentWire = (protocol, command, current) => command.produced
   { ...command, produced: { ...command.produced, wire: current.wire } },
   current
 );
+function upgradeLegacyAthenaStatement(protocol, command, current) {
+  if (protocol !== DEEP_AGENT_STATEWIRE_PROTOCOL || current.protocols === "*") return void 0;
+  const produced = command.produced;
+  if (produced === void 0 || produced.protocols === "*") return void 0;
+  const athena = produced.protocols.find((p) => p.name === protocol);
+  const offer = current.protocols.find((p) => p.name === protocol);
+  if ((athena == null ? void 0 : athena.version) !== DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION || offer === void 0 || inRange(athena.version, offer))
+    return void 0;
+  const upgraded = upgradeLegacyRunCommand(command);
+  if (upgraded === null && command.method in LEGACY_RUN_SEND_BEHAVIORS) return null;
+  return {
+    ...command,
+    ...upgraded ?? {},
+    produced: {
+      ...produced,
+      protocols: produced.protocols.map((p) => p.name === protocol ? offer : p)
+    }
+  };
+}
 function parkIncompatibleSessionCommands(record, current, now = Date.now()) {
   let parked = 0;
   let restamped = 0;
   const lanes = {};
+  const park = (command) => ({
+    id: command.id,
+    method: command.method,
+    params: command.params,
+    ...command.meta !== void 0 && { meta: command.meta },
+    ts: now,
+    ...command.seq !== void 0 && { seq: command.seq },
+    ...command.localMeta !== void 0 && { localMeta: command.localMeta },
+    failure: { fate: "lost", cause: "session-lost" }
+  });
   for (const [protocol, lane] of Object.entries(record.lanes)) {
-    const kept = [];
-    const failed = [];
+    const inbox = [];
     let laneRestamped = 0;
-    for (const command of lane.commands) {
-      if (storedCommandCompatible(protocol, command, current)) {
-        kept.push(command);
-        continue;
+    const sort = (stored) => stored.flatMap((original) => {
+      const upgraded = upgradeLegacyAthenaStatement(protocol, original, current);
+      if (upgraded === null) {
+        inbox.push(park(original));
+        return [];
+      }
+      const command = upgraded ?? original;
+      if (upgraded !== void 0 && storedCommandCompatible(protocol, command, current)) {
+        laneRestamped += 1;
+        return [command];
       }
+      if (storedCommandCompatible(protocol, command, current))
+        return [command];
       if (replayableOnCurrentWire(protocol, command, current)) {
-        kept.push({ ...command, produced: current });
         laneRestamped += 1;
-        continue;
+        return [{ ...command, produced: current }];
       }
-      failed.push({
-        protocol,
-        produced: current,
-        command: command.method,
-        params: command.params,
-        ...command.meta !== void 0 && { meta: command.meta },
-        failure: { fate: "lost", cause: "session-lost" },
-        ts: now,
-        seq: command.seq
-      });
-    }
-    parked += failed.length;
+      inbox.push(park(command));
+      return [];
+    });
+    const commands = sort(lane.commands);
+    const outbox = lane.outbox === void 0 ? void 0 : sort(lane.outbox);
+    parked += inbox.length;
     restamped += laneRestamped;
-    lanes[protocol] = failed.length === 0 && laneRestamped === 0 ? lane : {
-      ...lane,
-      commands: kept,
-      ...(failed.length > 0 || lane.failed !== void 0) && {
-        failed: [...lane.failed ?? [], ...failed]
+    const { outbox: _outbox, ...rest } = lane;
+    lanes[protocol] = inbox.length === 0 && laneRestamped === 0 ? lane : {
+      ...rest,
+      commands,
+      ...outbox !== void 0 && outbox.length > 0 && { outbox },
+      ...(inbox.length > 0 || lane.inbox !== void 0) && {
+        inbox: [...lane.inbox ?? [], ...inbox]
       }
     };
   }
@@ -108,21 +183,12 @@ function isStorageQuotaError(error) {
     message
   );
 }
-function asStatewireQuotaError(error) {
-  if (error instanceof Error && error.name === "QuotaExceededError")
-    return error;
-  const normalized = new Error(
-    error instanceof Error ? error.message : "storage quota exceeded"
-  );
-  normalized.name = "QuotaExceededError";
-  return normalized;
-}
-function unreadableRecord(raw) {
+function unreadableRecord(key, raw) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
-  } catch (error) {
-    return error instanceof Error ? error : new Error("stored session record is not JSON");
+  } catch {
+    return void 0;
   }
   if (typeof parsed !== "object" || parsed === null) {
     return new Error("stored session record is not an object");
@@ -133,6 +199,10 @@ function unreadableRecord(raw) {
       `stored session record uses storage version ${String(version)}`
     );
   }
+  const owner = parsed.principal;
+  if (version === 6 && typeof owner === "string" && !key.includes(`:${encodeURIComponent(owner)}:`)) {
+    return new Error("stored session record belongs to another principal");
+  }
   return void 0;
 }
 function browserBackend({
@@ -163,24 +233,48 @@ function browserBackend({
           );
         }
       );
+    },
+    subscribe: (listener) => {
+      var _a;
+      const onStorage = (event) => {
+        if (event.key !== null) listener(event.key);
+      };
+      (_a = browserGlobals.addEventListener) == null ? void 0 : _a.call(browserGlobals, "storage", onStorage);
+      return () => {
+        var _a2;
+        return (_a2 = browserGlobals.removeEventListener) == null ? void 0 : _a2.call(browserGlobals, "storage", onStorage);
+      };
     }
   };
 }
 function quotaTolerantBackend({
   inner,
-  onDegraded
+  onDegraded,
+  onQuota
 }) {
-  const quotaSurfaced = /* @__PURE__ */ new Set();
+  const reclaimed = /* @__PURE__ */ new Set();
   const overlay = /* @__PURE__ */ new Map();
   const shielded = /* @__PURE__ */ new Set();
   const checked = /* @__PURE__ */ new Map();
   const readable = (key, raw) => {
     const previous = checked.get(key);
     if (previous !== void 0 && previous.raw === raw) return previous.verdict;
-    const verdict = unreadableRecord(raw);
+    const verdict = unreadableRecord(key, raw);
     checked.set(key, { raw, verdict });
     return verdict;
   };
+  const writeThrough = (key) => {
+    const value = overlay.get(key);
+    if (value === void 0 || shielded.has(key)) return;
+    try {
+      inner.setItem(key, value);
+    } catch (error) {
+      onDegraded({ operation: "setItem", key, error });
+      return;
+    }
+    if (overlay.get(key) === value) overlay.delete(key);
+    reclaimed.delete(key);
+  };
   return {
     getItem: (key) => {
       const shadowed = overlay.get(key);
@@ -209,13 +303,17 @@ function quotaTolerantBackend({
       try {
         inner.setItem(key, value);
         overlay.delete(key);
-        quotaSurfaced.delete(key);
+        reclaimed.delete(key);
       } catch (error) {
-        if (isStorageQuotaError(error) && !quotaSurfaced.has(key)) {
-          quotaSurfaced.add(key);
-          throw asStatewireQuotaError(error);
-        }
         overlay.set(key, value);
+        if (isStorageQuotaError(error) && onQuota && !reclaimed.has(key)) {
+          reclaimed.add(key);
+          onQuota(key).then(
+            () => writeThrough(key),
+            (reclaimError) => onDegraded({ operation: "withUnused", key, error: reclaimError })
+          );
+          return;
+        }
         onDegraded({ operation: "setItem", key, error });
       }
     },
@@ -243,10 +341,12 @@ function quotaTolerantBackend({
       } catch (error) {
         onDegraded({ operation: "withUnused", key, error });
       }
-    }
+    },
+    ...inner.subscribe !== void 0 && { subscribe: inner.subscribe }
   };
 }
-function savedAtOf(raw) {
+const asList = (value) => Array.isArray(value) ? value : [];
+function retentionView(raw) {
   if (raw === null) return void 0;
   let parsed;
   try {
@@ -255,23 +355,61 @@ function savedAtOf(raw) {
     return void 0;
   }
   if (typeof parsed !== "object" || parsed === null) return void 0;
-  const { savedAt, updatedAt } = parsed;
-  const stamp = savedAt ?? updatedAt;
-  return typeof stamp === "number" && Number.isFinite(stamp) ? stamp : void 0;
+  const record = parsed;
+  const stamp = record.savedAt ?? record.updatedAt;
+  const lanes = typeof record.lanes === "object" && record.lanes !== null ? Object.values(record.lanes) : [];
+  const holdsSends = asList(record.commands).length > 0 || asList(record.failed).length > 0 || lanes.some((lane) => {
+    if (typeof lane !== "object" || lane === null) return false;
+    const fields = lane;
+    return [
+      "commands",
+      "outbox",
+      "inbox",
+      "removed",
+      "verdicts",
+      "failed"
+    ].some((field) => asList(fields[field]).length > 0);
+  });
+  return {
+    savedAt: typeof stamp === "number" && Number.isFinite(stamp) ? stamp : void 0,
+    holdsSends
+  };
+}
+function persistedSessionHoldsSends(sessionKey) {
+  var _a;
+  const storage = browserGlobals.localStorage;
+  if (!storage) return false;
+  let raw;
+  try {
+    raw = storage.getItem(SESSION_PREFIX + sessionKey);
+  } catch {
+    return false;
+  }
+  return ((_a = retentionView(raw)) == null ? void 0 : _a.holdsSends) ?? false;
 }
 async function retireExpiredSessionRecords({
   backend,
   mounted,
   maxAgeMs,
+  quota = false,
   now = Date.now()
 }) {
+  const empty = [];
   for (const key of backend.getAllKeys()) {
     if (!key.startsWith(SESSION_PREFIX) || mounted.has(key)) continue;
-    const savedAt = savedAtOf(backend.getItem(key));
-    if (savedAt === void 0 || now - savedAt <= maxAgeMs) continue;
+    const view = retentionView(backend.getItem(key));
+    if ((view == null ? void 0 : view.savedAt) === void 0 || view.holdsSends) continue;
+    empty.push({ key, savedAt: view.savedAt });
+  }
+  empty.sort((a, b) => b.savedAt - a.savedAt);
+  const quotaStart = Math.floor(empty.length / 2);
+  for (const [index, { key, savedAt }] of empty.entries()) {
+    const expired = now - savedAt > maxAgeMs;
+    if (!expired && !(quota && index >= quotaStart)) continue;
     await backend.withUnused(key, async () => {
-      if (mounted.has(key) || savedAtOf(backend.getItem(key)) !== savedAt)
-        return;
+      if (mounted.has(key)) return;
+      const again = retentionView(backend.getItem(key));
+      if ((again == null ? void 0 : again.savedAt) !== savedAt || again.holdsSends) return;
       backend.removeItem(key);
     });
   }
@@ -284,26 +422,63 @@ function sharedBackend({
   let shared = sharedBackends.get(storage);
   if (shared === void 0) {
     const listeners = /* @__PURE__ */ new Set();
+    const mounted = /* @__PURE__ */ new Map();
+    const maxAgeMs = /* @__PURE__ */ new Map();
+    const inner = browserBackend({ storage, locks });
     shared = {
       listeners,
-      mounted: /* @__PURE__ */ new Map(),
+      mounted,
+      maxAgeMs,
       backend: quotaTolerantBackend({
-        inner: browserBackend({ storage, locks }),
+        inner,
         onDegraded: (degradation) => {
           for (const listener of listeners) listener(degradation);
-        }
+        },
+        onQuota: () => retireExpiredSessionRecords({
+          backend: inner,
+          mounted,
+          maxAgeMs: Math.max(7 * DAY_MS, ...maxAgeMs.values()),
+          quota: true
+        })
       })
     };
     sharedBackends.set(storage, shared);
   }
   return shared;
 }
+async function underLock({
+  locks,
+  name,
+  fn,
+  onRefused
+}) {
+  let granted = false;
+  try {
+    return await locks.request(name, async () => {
+      granted = true;
+      return fn();
+    });
+  } catch (error) {
+    if (granted) throw error;
+    onRefused(error);
+    return fn();
+  }
+}
+function newTabId() {
+  var _a, _b;
+  const host = globalThis;
+  return ((_b = (_a = host.crypto) == null ? void 0 : _a.randomUUID) == null ? void 0 : _b.call(_a)) ?? `tab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
 const useQuotaSafeLocalStorageSession = ({
   threadId,
-  key = (id) => id,
+  namespace,
+  principal,
+  unscopedPrefix,
   ttl = 7 * DAY_MS,
   max = 50,
-  onStorageDegraded
+  recordBytes = LOCAL_SESSION_RECORD_BYTES,
+  onStorageDegraded,
+  onEvict
 }) => {
   var _a;
   const storage = browserGlobals.localStorage;
@@ -316,18 +491,31 @@ const useQuotaSafeLocalStorageSession = ({
     throw new Error(
       "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
     );
-  const sessionKey = key(threadId);
+  const sessionKey = localStorageSessionKey({ namespace, principal, threadId });
   const storageKey = SESSION_PREFIX + sessionKey;
   const lockName = SESSION_LOCK_PREFIX + sessionKey;
   const mountedScope = useRef({
     threadId,
     laneKey: sessionKey
   });
-  if (!isSameSessionLaneScope({ scope: mountedScope.current, key })) {
+  if (!isSameSessionLaneScope({
+    scope: mountedScope.current,
+    key: (id) => localStorageSessionKey({ namespace, principal, threadId: id })
+  })) {
     throw new Error(
       "statewire: principal changed; remount the account's thread/session"
     );
   }
+  useMemo(() => {
+    if (unscopedPrefix === void 0) return;
+    adoptUnscopedLocalStorageSessions({
+      namespace,
+      principal,
+      unscopedPrefix,
+      threadId,
+      storage
+    });
+  }, [namespace, principal, unscopedPrefix, threadId, storage]);
   const latestOnDegraded = useRef(onStorageDegraded);
   latestOnDegraded.current = onStorageDegraded;
   const reportDegradation = useMemo(() => {
@@ -350,6 +538,18 @@ const useQuotaSafeLocalStorageSession = ({
       );
     };
   }, []);
+  const latestOnEvict = useRef(onEvict);
+  latestOnEvict.current = onEvict;
+  const reportEvict = useCallback(
+    (event) => {
+      var _a2;
+      try {
+        (_a2 = latestOnEvict.current) == null ? void 0 : _a2.call(latestOnEvict, event);
+      } catch {
+      }
+    },
+    []
+  );
   const shared = sharedBackend({ storage, locks });
   shared.listeners.add(reportDegradation);
   useEffect(() => {
@@ -359,8 +559,9 @@ const useQuotaSafeLocalStorageSession = ({
     };
   }, [shared, reportDegradation]);
   useEffect(() => {
-    const { mounted } = shared;
+    const { mounted, maxAgeMs } = shared;
     mounted.set(storageKey, (mounted.get(storageKey) ?? 0) + 1);
+    maxAgeMs.set(storageKey, ttl);
     retireExpiredSessionRecords({
       backend: shared.backend,
       mounted,
@@ -370,10 +571,23 @@ const useQuotaSafeLocalStorageSession = ({
     );
     return () => {
       const count = (mounted.get(storageKey) ?? 1) - 1;
-      if (count === 0) mounted.delete(storageKey);
-      else mounted.set(storageKey, count);
+      if (count === 0) {
+        mounted.delete(storageKey);
+        maxAgeMs.delete(storageKey);
+      } else mounted.set(storageKey, count);
     };
   }, [shared, storageKey, ttl, reportDegradation]);
+  const [tabId] = useState(newTabId);
+  useEffect(() => {
+    let release;
+    const held = new Promise((resolve) => {
+      release = resolve;
+    });
+    Promise.resolve(locks.request(TAB_LOCK_PREFIX + tabId, () => held)).catch(
+      (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+    );
+    return () => release == null ? void 0 : release();
+  }, [locks, tabId, storageKey, reportDegradation]);
   useEffect(() => {
     let release;
     let disposed = false;
@@ -414,31 +628,42 @@ const useQuotaSafeLocalStorageSession = ({
   const sessionStorage = useResource(
     KeyValueSessionStorage({
       backend: shared.backend,
-      key: sessionKey,
-      namespace: SESSION_PREFIX,
+      key: threadId,
+      namespace: SESSION_PREFIX + namespace,
+      principal,
       protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
       migrate,
+      // statewire 0.27.1 retires a record past maxAgeMs even while it holds
+      // sends: kept failures with their full params were what filled the
+      // origin (#52031).
       retention: { maxAgeMs: ttl, maxEntries: max },
+      limits: { recordBytes },
       // A failure statewire raises itself (a structurally invalid stored
       // record) still stops the session; it is at least reported the same way.
-      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error })
+      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error }),
+      onEvict: reportEvict
     })
   );
   return useMemo(
     () => ({
       ...sessionStorage,
-      lock: async (fn) => {
-        let granted = false;
-        try {
-          return await locks.request(lockName, async () => {
-            granted = true;
-            return fn();
-          });
-        } catch (error) {
-          if (granted) throw error;
-          reportDegradation({ operation: "lock", key: storageKey, error });
-          return fn();
-        }
+      lock: (fn) => underLock({
+        locks,
+        name: lockName,
+        fn,
+        onRefused: (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+      }),
+      notifyLock: (fn) => underLock({
+        locks,
+        name: NOTIFY_LOCK_PREFIX + storageKey,
+        fn,
+        onRefused: (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+      }),
+      owner: {
+        id: tabId,
+        whenGone: (id, signal) => Promise.resolve(
+          locks.request(TAB_LOCK_PREFIX + id, { signal }, () => void 0)
+        )
       },
       subscribe: (listener) => {
         var _a2;
@@ -452,20 +677,25 @@ const useQuotaSafeLocalStorageSession = ({
         };
       }
     }),
-    [sessionStorage, locks, storageKey, lockName, reportDegradation]
+    [sessionStorage, locks, storageKey, lockName, tabId, reportDegradation]
   );
 };
 const QuotaSafeLocalStorageSession = resource(
   useQuotaSafeLocalStorageSession
 );
 export {
+  LOCAL_SESSION_RECORD_BYTES,
   QuotaSafeLocalStorageSession,
   STORED_STATEMENT_WIRE_FLOOR,
+  adoptUnscopedLocalStorageSessions,
   isStorageQuotaError,
+  localStorageSessionKey,
   parkIncompatibleSessionCommands,
+  persistedSessionHoldsSends,
   quotaTolerantBackend,
   readFailedSendStampsFromRecord,
   readPersistedFailedSendStamps,
-  retireExpiredSessionRecords
+  retireExpiredSessionRecords,
+  sessionPrincipal
 };
 //# sourceMappingURL=quota-safe-local-storage-session.js.map