@athenaintel/react 0.41.2 → 0.42.1

package/dist/provider/AthenaProvider.js

@@ -1,6 +1,8 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { AuiProvider, AuiConfig, useAui } from "@assistant-ui/react";
 import { useMemo, useRef, useEffect, useContext, useState, useCallback, useReducer, useLayoutEffect } from "react";
+import { useKeptSnapshotsGate, AthenaOfflineSnapshotsContext } from "../offline/offline-history.js";
+import { chatOutboxStoreFor } from "../offline/chat-outbox.js";
 import { getAthenaEnvironmentUrls, deriveAthenaAppUrl, assertHostMintedStatewireMount, resolveStatewireSyncUrl } from "../lib/athena-urls.js";
 import { getAthenaApiBaseUrl } from "../collab/mint.js";
 import { useParentBridge } from "../runtime/auth.js";
@@ -9,12 +11,15 @@ import { AthenaCredentialSourceContext } from "../auth/AthenaCredentialSourceCon
 import { createAthenaCredentialSource } from "../auth/credential-source.js";
 import { useRestartAfterAuthRefusal } from "../runtime/auth-refusal-restart.js";
 import { useStatewireClientTools, useAthenaStatewireRuntime } from "../runtime/useAthenaStatewireRuntime.js";
+import { statewireSessionPrincipal } from "../runtime/statewire-session-key.js";
+import { createStatewireSessionLaneGate, StatewireSessionLaneContext } from "../runtime/statewire-session-lane.js";
 import { isStatewireChannelLive, statewireLifecycleReducer, initialStatewireLifecycle, athenaStatewireErrorNotice } from "../runtime/statewire-lifecycle.js";
+import { sendWithCredentialRenewal } from "../runtime/credential-renewal.js";
 import { resolveAgentProp } from "../runtime/statewire-run-config.js";
 import { providerThreadConfig } from "../runtime/statewire-thread-config-lane.js";
 import { mintThreadId } from "../threads/mint-thread-id.js";
 import { AthenaStatewireLifecycleContext } from "./statewire-lifecycle-context.js";
-import { createComposerHandoffStore, clearComposerHandoff, ComposerHandoffContext, useComposerHandoffStore, useComposerReady, drainComposerHandoff } from "../composer/composer-handoff.js";
+import { createComposerHandoffStore, clearComposerHandoff, ComposerHandoffContext, useComposerHandoffStore, useComposerReady, drainComposerHandoff, rememberRestoredAttachments } from "../composer/composer-handoff.js";
 import { createStatewireHistoryStore, StatewireHistoryContext } from "./statewire-history-context.js";
 import { StatewireToolOutputsContext } from "./statewire-window-context.js";
 import { StatewireClientToolBridge } from "../chat/StatewireClientToolBridge.js";
@@ -34,10 +39,15 @@ import { useAssetPanelStore } from "../assets/asset-panel-store.js";
 import { themeToStyleVars } from "../theme/index.js";
 import { AthenaThemeStyleContext } from "./theme-style-context.js";
 import { PostHogProvider } from "./PostHogProvider.js";
+import { createThreadSnapshotMirror } from "../agent-runtime/src/thread-snapshot-mirror.js";
+import { createDurableThreadSnapshotCache } from "../agent-runtime/src/durable-thread-snapshot-cache.js";
 import { createDeepAgentThreadSnapshotCache } from "../agent-runtime/src/thread-snapshot-cache.js";
+import { createChatOutboxAttachmentCheck, chatOutboxAttachmentPath } from "../agent-runtime/src/chat-outbox-attachments.js";
 import { createDeepAgentToolOutputStore } from "../agent-runtime/src/tool-outputs.js";
 import { DeepAgentConnectionContext } from "../agent-runtime/src/thread-status.js";
+import { DeepAgentChatOutboxContext, useDeepAgentChatOutbox } from "../agent-runtime/src/use-deep-agent-chat-outbox.js";
 import { readServerConfig } from "../agent-runtime/src/use-deep-agent-config.js";
+import { browserOnlineSignal, allChatOutboxSignals, documentVisibleSignal } from "../agent-runtime/src/chat-outbox-signals.js";
 const resolveTokenOverride = ({
   config,
   token
@@ -99,6 +109,7 @@ function ComposerHandoffDrain() {
   return null;
 }
 const EMPTY_MODES = [];
+const CHAT_OUTBOX_ATTACHMENT_READ_TIMEOUT_MS = 1e4;
 function withEntry(record, key, value) {
   if (value === null) {
     if (!(key in record)) return record;
@@ -133,8 +144,12 @@ function AthenaStatewireRuntimeMount({
   appId,
   extraRunConfig,
   snapshotCache,
-  toolOutputs
+  toolOutputs,
+  chatOutbox = null,
+  sessionLane,
+  subagentLaneHistory
 }) {
+  const outboxRef = useRef(null);
   const [lifecycle, dispatchLifecycle] = useReducer(
     statewireLifecycleReducer,
     initialStatewireLifecycle
@@ -163,6 +178,7 @@ function AthenaStatewireRuntimeMount({
     extraRunConfig,
     snapshotCache,
     toolOutputs,
+    subagentLaneHistory,
     // The runtime already records every transport error on the diagnostics
     // bus (with the channel-teardown split), so this layer only maps it to
     // the banner notice.
@@ -176,6 +192,10 @@ function AthenaStatewireRuntimeMount({
     onRawConnectionChange: (connection) => {
       dispatchLifecycle({ type: "raw-connection", reconnect: connection.reconnect });
     },
+    onCommandChange: (update) => {
+      var _a;
+      return (_a = outboxRef.current) == null ? void 0 : _a.observeCommand(update);
+    },
     // The lane as the host holds it: anything that decides from the lane waits
     // for this, never the placeholder or remembered snapshot rendered before.
     onServerState: (state) => {
@@ -183,6 +203,64 @@ function AthenaStatewireRuntimeMount({
       setServerLane((previous) => nextServerLane({ previous, config }));
     }
   });
+  const lanePending = statewireSessionPrincipal(useContext(AthenaAuthContext)) === null;
+  useEffect(() => {
+    sessionLane.setPending(lanePending);
+  }, [sessionLane, lanePending]);
+  const connectionRef = useRef(lifecycle.connection);
+  connectionRef.current = lifecycle.connection;
+  const [connectionListeners] = useState(() => /* @__PURE__ */ new Set());
+  useEffect(() => {
+    for (const listener of connectionListeners) listener();
+  }, [lifecycle.connection, connectionListeners]);
+  const [channelReachability] = useState(() => ({
+    get: () => {
+      var _a;
+      return ((_a = connectionRef.current) == null ? void 0 : _a.status) !== "retrying";
+    },
+    subscribe: (listener) => {
+      connectionListeners.add(listener);
+      return () => {
+        connectionListeners.delete(listener);
+      };
+    }
+  }));
+  const [browserOnline] = useState(browserOnlineSignal);
+  const hostReachability = chatOutbox == null ? void 0 : chatOutbox.reachability;
+  const reachability = useMemo(
+    () => allChatOutboxSignals(hostReachability ?? browserOnline, channelReachability),
+    [hostReachability, browserOnline, channelReachability]
+  );
+  const [defaultForeground] = useState(documentVisibleSignal);
+  const composerHandoff = useComposerHandoffStore();
+  const outbox = useDeepAgentChatOutbox({
+    client,
+    threadId,
+    isNewChat,
+    store: (chatOutbox == null ? void 0 : chatOutbox.store) ?? null,
+    reachability,
+    foreground: (chatOutbox == null ? void 0 : chatOutbox.foreground) ?? defaultForeground,
+    // Cancel and Edit give the draft back, after anything typed since. Its attachments come back
+    // as mentions in it, remembered so a message held again from it is asked about again.
+    restore: (entry) => {
+      const draft = entry.composerMarkdown ?? entry.text;
+      const current = client.composer.getState().text ?? "";
+      client.composer.setText(current.trim() ? `${current}
+
+${draft}` : draft);
+      if (composerHandoff && entry.attachments) {
+        rememberRestoredAttachments({
+          store: composerHandoff,
+          threadId,
+          attachments: entry.attachments
+        });
+      }
+    },
+    ...(chatOutbox == null ? void 0 : chatOutbox.openThread) && { openThread: chatOutbox.openThread },
+    ...(chatOutbox == null ? void 0 : chatOutbox.checkAttachments) && { checkAttachments: chatOutbox.checkAttachments },
+    enabled: chatOutbox !== null
+  });
+  outboxRef.current = outbox;
   useRestartAfterAuthRefusal({
     connection: lifecycle.connection,
     reconnect: lifecycle.reconnect
@@ -216,9 +294,10 @@ function AthenaStatewireRuntimeMount({
       client,
       lifecycle: lifecycleValue,
       serverLane,
-      threadConfig
+      threadConfig,
+      outbox
     }),
-    [threadId, isNewChat, client, lifecycleValue, serverLane, threadConfig]
+    [threadId, isNewChat, client, lifecycleValue, serverLane, threadConfig, outbox]
   );
   useLayoutEffect(() => {
     onPublish(snapshot);
@@ -318,7 +397,7 @@ function AthenaStatewireStandalone({
       published.threadId
     ),
     /* @__PURE__ */ jsx(ComposerHandoffDrain, {}),
-    /* @__PURE__ */ jsx(AthenaChatModeSelectionContext.Provider, { value: chatModeSelection, children })
+    /* @__PURE__ */ jsx(DeepAgentChatOutboxContext.Provider, { value: published.outbox, children: /* @__PURE__ */ jsx(AthenaChatModeSelectionContext.Provider, { value: chatModeSelection, children }) })
   ] }) }) }) }) }) }) }) }) });
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(
@@ -352,6 +431,7 @@ function AthenaStatewireWithThreadList({
   initialThreadId,
   includePullRequests,
   additionalListAppIds,
+  offlineList,
   ...standaloneProps
 }) {
   return /* @__PURE__ */ jsx(
@@ -366,6 +446,7 @@ function AthenaStatewireWithThreadList({
       additionalListAppIds,
       initialThreadId,
       includePullRequests,
+      offlineList,
       snapshotCache: standaloneProps.snapshotCache,
       children: /* @__PURE__ */ jsx(
         AthenaStatewireActiveThreadHost,
@@ -385,15 +466,25 @@ function AthenaStatewireWithThreadList({
 }
 function AthenaStatewireActiveThreadHost({
   children,
+  chatOutbox,
   ...standaloneProps
 }) {
   const list = useAthenaStatewireThreadList();
+  const selectThread = list == null ? void 0 : list.selectThread;
+  const outboxHost = useMemo(
+    () => chatOutbox && !chatOutbox.openThread && selectThread ? {
+      ...chatOutbox,
+      openThread: ({ threadId, newChat }) => selectThread(threadId, { isNew: newChat })
+    } : chatOutbox,
+    [chatOutbox, selectThread]
+  );
   if (!list) return null;
   return /* @__PURE__ */ jsxs(
     AthenaStatewireStandalone,
     {
       threadId: list.activeThreadId,
       threadList: { isNewChat: list.isNewChat },
+      chatOutbox: outboxHost,
       ...standaloneProps,
       children: [
         /* @__PURE__ */ jsx(StatewireThreadTitlePoller, {}),
@@ -446,7 +537,10 @@ function AthenaProvider({
   posthog: posthogProp,
   debug,
   onDiagnostic,
-  onError
+  onError,
+  offlineHistory,
+  chatOutbox,
+  subagentLaneHistory = false
 }) {
   var _a;
   const agentAssetId = resolveAgentProp({ agent });
@@ -523,7 +617,87 @@ function AthenaProvider({
   });
   const authContext = useContext(AthenaAuthContext);
   const authProviderToken = (authContext == null ? void 0 : authContext.accessToken) ?? null;
-  const [snapshotCache] = useState(() => createDeepAgentThreadSnapshotCache());
+  const offlineHistoryRef = useRef(offlineHistory);
+  offlineHistoryRef.current = offlineHistory;
+  const isOfflineNow = () => {
+    var _a2, _b;
+    return ((_b = (_a2 = offlineHistoryRef.current) == null ? void 0 : _a2.isOffline) == null ? void 0 : _b.call(_a2)) ?? (typeof navigator !== "undefined" && navigator.onLine === false);
+  };
+  const [offlineMirror] = useState(
+    () => offlineHistory ? createThreadSnapshotMirror({
+      getKey: (ownerId) => {
+        const host = offlineHistoryRef.current;
+        return host && host.ownerId === ownerId ? host.getKey() : Promise.resolve(null);
+      }
+    }) : null
+  );
+  const [durableSnapshotCache] = useState(
+    () => offlineMirror ? createDurableThreadSnapshotCache({ mirror: offlineMirror, isOffline: isOfflineNow }) : null
+  );
+  const [snapshotCache] = useState(
+    () => durableSnapshotCache ?? createDeepAgentThreadSnapshotCache()
+  );
+  const chatOutboxRef = useRef(chatOutbox);
+  chatOutboxRef.current = chatOutbox;
+  const chatOutboxOwnerId = (chatOutbox == null ? void 0 : chatOutbox.ownerId) ?? null;
+  const chatOutboxStore = useMemo(() => {
+    const host = chatOutboxRef.current;
+    return host && host.ownerId === chatOutboxOwnerId ? chatOutboxStoreFor(host) : null;
+  }, [chatOutboxOwnerId]);
+  useEffect(() => {
+    if (chatOutbox) chatOutboxStoreFor(chatOutbox);
+  }, [chatOutbox]);
+  const chatOutboxReachability = chatOutbox == null ? void 0 : chatOutbox.reachability;
+  const chatOutboxForeground = chatOutbox == null ? void 0 : chatOutbox.foreground;
+  const chatOutboxOpenThread = chatOutbox == null ? void 0 : chatOutbox.openThread;
+  const outboxCheckAuthRef = useRef({});
+  const outboxCheckBackendRef = useRef("");
+  const [checkChatOutboxAttachments] = useState(
+    () => createChatOutboxAttachmentCheck({
+      readAsset: (assetId) => sendWithCredentialRenewal(
+        outboxCheckAuthRef.current,
+        (headers) => fetch(`${outboxCheckBackendRef.current}${chatOutboxAttachmentPath(assetId)}`, {
+          method: "GET",
+          headers,
+          signal: AbortSignal.timeout(CHAT_OUTBOX_ATTACHMENT_READ_TIMEOUT_MS)
+        })
+      )
+    })
+  );
+  const chatOutboxHost = useMemo(
+    () => chatOutboxOwnerId === null ? null : {
+      store: chatOutboxStore,
+      ...chatOutboxReachability && { reachability: chatOutboxReachability },
+      ...chatOutboxForeground && { foreground: chatOutboxForeground },
+      ...chatOutboxOpenThread && { openThread: chatOutboxOpenThread },
+      checkAttachments: checkChatOutboxAttachments
+    },
+    [
+      chatOutboxOwnerId,
+      chatOutboxStore,
+      chatOutboxReachability,
+      chatOutboxForeground,
+      chatOutboxOpenThread,
+      checkChatOutboxAttachments
+    ]
+  );
+  const offlineOwnerId = (offlineHistory == null ? void 0 : offlineHistory.ownerId) ?? null;
+  const awaitingKeptSnapshots = useKeptSnapshotsGate({
+    cache: durableSnapshotCache,
+    ownerId: offlineOwnerId,
+    isOffline: isOfflineNow
+  });
+  const offlineSnapshots = useMemo(
+    () => durableSnapshotCache ? {
+      offlineSeedAt: (threadId) => durableSnapshotCache.offlineSeedAt(threadId),
+      subscribeOfflineSeeds: (listener) => durableSnapshotCache.subscribeOfflineSeeds(listener)
+    } : null,
+    [durableSnapshotCache]
+  );
+  const offlineList = useMemo(
+    () => offlineMirror && offlineOwnerId ? { mirror: offlineMirror, ownerId: offlineOwnerId } : void 0,
+    [offlineMirror, offlineOwnerId]
+  );
   const [composerHandoff] = useState(createComposerHandoffStore);
   const [toolOutputs] = useState(() => createDeepAgentToolOutputStore());
   const [historyStore] = useState(createStatewireHistoryStore);
@@ -531,8 +705,21 @@ function AthenaProvider({
   useEffect(() => {
     snapshotCache.clear();
     toolOutputs.clear();
-    clearComposerHandoff({ store: composerHandoff, reason: "the signed-in identity changed" });
-  }, [snapshotCache, toolOutputs, composerHandoff, principal, configuredApiKey]);
+  }, [snapshotCache, toolOutputs, principal, configuredApiKey]);
+  const sessionPrincipal = statewireSessionPrincipal(authContext);
+  const [sessionLane] = useState(
+    () => createStatewireSessionLaneGate({ pending: sessionPrincipal === null })
+  );
+  const handoffIdentityRef = useRef(null);
+  useEffect(() => {
+    if (sessionPrincipal === null) return;
+    const identity = JSON.stringify([sessionPrincipal, configuredApiKey ?? null]);
+    const previous = handoffIdentityRef.current;
+    handoffIdentityRef.current = identity;
+    if (previous !== null && previous !== identity) {
+      clearComposerHandoff({ store: composerHandoff, reason: "the signed-in identity changed" });
+    }
+  }, [composerHandoff, sessionPrincipal, configuredApiKey]);
   useEffect(
     () => () => clearComposerHandoff({ store: composerHandoff, reason: "the chat provider unmounted" }),
     [composerHandoff]
@@ -556,6 +743,12 @@ function AthenaProvider({
   const effectiveBackendUrl = getAthenaApiBaseUrl(
     configuredBackendUrl ?? bridge.backendBaseUrl ?? environmentUrls.backendUrl
   );
+  outboxCheckBackendRef.current = effectiveBackendUrl;
+  outboxCheckAuthRef.current = {
+    apiKey: configuredApiKey,
+    token: effectiveToken,
+    getToken: credentialGetToken
+  };
   const hostStatewireSyncUrl = configuredStatewireSyncUrl ?? bridge.statewireSyncUrl ?? void 0;
   const effectiveAppUrl = configuredAppUrl ?? bridge.appUrl ?? deriveAthenaAppUrl({ apiUrl: effectiveApiUrl, backendUrl: effectiveBackendUrl }) ?? environmentUrls.appUrl;
   if (!bridge.ready) {
@@ -596,6 +789,9 @@ function AthenaProvider({
     snapshotCache,
     toolOutputs,
     historyStore,
+    chatOutbox: chatOutboxHost,
+    sessionLane,
+    subagentLaneHistory,
     linkClicks,
     citationLinks
   };
@@ -606,6 +802,7 @@ function AthenaProvider({
       initialThreadId: threadIdProp,
       includePullRequests: threadListIncludePullRequests,
       additionalListAppIds: threadListAdditionalAppIds,
+      offlineList,
       children
     }
   ) : (
@@ -627,7 +824,7 @@ function AthenaProvider({
     {
       className: themeStyleVars ? "athena-sdk athena-themed" : "athena-sdk",
       style: themeStyleVars,
-      children: /* @__PURE__ */ jsx(PostHogProvider, { config: posthogConfig, children: /* @__PURE__ */ jsx(ComposerHandoffContext.Provider, { value: composerHandoff, children: /* @__PURE__ */ jsx(AthenaThemeStyleContext.Provider, { value: themeStyleVars, children: /* @__PURE__ */ jsx(AthenaCredentialSourceContext.Provider, { value: credentials, children: /* @__PURE__ */ jsx(AthenaAgentSelectionContext.Provider, { value: agentSelection, children: inner }) }) }) }) })
+      children: /* @__PURE__ */ jsx(PostHogProvider, { config: posthogConfig, children: /* @__PURE__ */ jsx(ComposerHandoffContext.Provider, { value: composerHandoff, children: /* @__PURE__ */ jsx(StatewireSessionLaneContext.Provider, { value: sessionLane, children: /* @__PURE__ */ jsx(AthenaThemeStyleContext.Provider, { value: themeStyleVars, children: /* @__PURE__ */ jsx(AthenaCredentialSourceContext.Provider, { value: credentials, children: /* @__PURE__ */ jsx(AthenaAgentSelectionContext.Provider, { value: agentSelection, children: /* @__PURE__ */ jsx(AthenaOfflineSnapshotsContext.Provider, { value: offlineSnapshots, children: awaitingKeptSnapshots ? null : inner }) }) }) }) }) }) })
     }
   );
 }