@athenaintel/react 0.41.2 → 0.42.1

package/dist/offline/offline-history.js

@@ -0,0 +1,77 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { CloudOffIcon } from "lucide-react";
+import { useContext, useSyncExternalStore, useState, useEffect, createContext } from "react";
+import { useAthenaThreadId } from "../threads/thread-id-context.js";
+import { cn } from "cnfast";
+const OFFLINE_SNAPSHOT_READ_WAIT_MS = 1500;
+function useKeptSnapshotsGate({
+  cache,
+  ownerId,
+  isOffline,
+  waitMs = OFFLINE_SNAPSHOT_READ_WAIT_MS
+}) {
+  const [readFor, setReadFor] = useState(void 0);
+  useEffect(() => {
+    if (!cache) return;
+    let live = true;
+    const settle = () => {
+      if (live) setReadFor(ownerId);
+    };
+    const timer = setTimeout(settle, waitMs);
+    const done = () => {
+      clearTimeout(timer);
+      settle();
+    };
+    void cache.setOwner(ownerId).then(done, done);
+    return () => {
+      live = false;
+      clearTimeout(timer);
+    };
+  }, [cache, ownerId, waitMs]);
+  const [mountedOffline] = useState(() => cache !== null && isOffline());
+  return mountedOffline && ownerId !== null && readFor !== ownerId;
+}
+const AthenaOfflineSnapshotsContext = createContext(null);
+const noSubscription = () => () => void 0;
+const serverSnapshot = () => null;
+function useAthenaOfflineSnapshotAt(threadId) {
+  const snapshots = useContext(AthenaOfflineSnapshotsContext);
+  return useSyncExternalStore(
+    snapshots ? (listener) => snapshots.subscribeOfflineSeeds(listener) : noSubscription,
+    () => snapshots && threadId ? snapshots.offlineSeedAt(threadId) : null,
+    serverSnapshot
+  );
+}
+function formatOfflineSnapshotTime(at) {
+  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium", timeStyle: "short" }).format(at);
+}
+const OfflineSnapshotBanner = ({ className }) => {
+  const at = useAthenaOfflineSnapshotAt(useAthenaThreadId());
+  if (at === null) return null;
+  return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "status",
+      className: cn(
+        "mx-auto flex w-full max-w-(--thread-max-width) items-center gap-2 rounded-md border px-3 py-2 text-xs",
+        "border-border bg-muted text-muted-foreground"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(CloudOffIcon, { className: "size-3.5 shrink-0", "aria-hidden": true }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          "Offline · this conversation as of ",
+          formatOfflineSnapshotTime(at)
+        ] })
+      ]
+    }
+  ) });
+};
+export {
+  AthenaOfflineSnapshotsContext,
+  OFFLINE_SNAPSHOT_READ_WAIT_MS,
+  OfflineSnapshotBanner,
+  formatOfflineSnapshotTime,
+  useAthenaOfflineSnapshotAt,
+  useKeptSnapshotsGate
+};
+//# sourceMappingURL=offline-history.js.map

package/dist/offline/offline-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-history.js","sources":["../../src/offline/offline-history.tsx"],"sourcesContent":["import type { DurableThreadSnapshotCache } from '@athenaintel/agent-runtime';\nimport { CloudOffIcon } from 'lucide-react';\nimport {\n  createContext,\n  type FC,\n  useContext,\n  useEffect,\n  useState,\n  useSyncExternalStore,\n} from 'react';\nimport { cn } from '../lib/utils';\nimport { useAthenaThreadId } from '../threads/thread-id-context';\n\n/**\n * Opt-in: keep the chat's recent conversations, and the session list, on this device, sealed with\n * the host's key, so a reload paints them at once and they can be read while Athena can't be\n * reached (`AthenaProvider`'s `offlineHistory`). Without it nothing is stored, as before.\n *\n * - `ownerId` names whose they are (the signed-in person). Changing it drops what the previous\n *   owner kept, in memory and on the device (the session list's cached pages too); nothing kept\n *   under one owner is ever shown to another. Passing no `offlineHistory` any more (a deployment\n *   that now keeps nothing on devices) drops it all the same.\n * - `getKey` returns the AES-GCM key that seals them, for that owner, or `null` to keep nothing\n *   (no key, a deployment that keeps nothing on devices). Midas's comes from its main process,\n *   kept with the OS keychain and handed to the page only for the signed-in person.\n * - `isOffline` says Athena can't be reached (the browser's own offline when omitted): then a\n *   conversation opens on its last resting transcript this device holds, up to 30 days old, marked\n *   \"as of\" when it was captured; a chat that mounts offline waits (at most\n *   {@link OFFLINE_SNAPSHOT_READ_WAIT_MS}) for what the device kept to be read.\n */\nexport interface AthenaOfflineHistory {\n  ownerId: string;\n  getKey: () => Promise<CryptoKey | null>;\n  isOffline?: () => boolean;\n}\n\n/**\n * How long a chat that mounts offline waits for what this device kept before it mounts without:\n * the host's key and IndexedDB answer in milliseconds unless something is stuck.\n */\nexport const OFFLINE_SNAPSHOT_READ_WAIT_MS = 1_500;\n\n/**\n * Binds `cache` to `ownerId`, and says whether a chat that mounted offline still waits for what\n * this device kept for that owner to be read (at most `waitMs`). The runtime takes a thread's seed\n * once, as it mounts, and offline that seed is all a thread can show; online it never waits, the\n * attach delivers the thread.\n */\nexport function useKeptSnapshotsGate({\n  cache,\n  ownerId,\n  isOffline,\n  waitMs = OFFLINE_SNAPSHOT_READ_WAIT_MS,\n}: {\n  cache: Pick<DurableThreadSnapshotCache, 'setOwner'> | null;\n  ownerId: string | null;\n  isOffline: () => boolean;\n  waitMs?: number;\n}): boolean {\n  const [readFor, setReadFor] = useState<string | null | undefined>(undefined);\n  useEffect(() => {\n    if (!cache) return;\n    let live = true;\n    const settle = () => {\n      if (live) setReadFor(ownerId);\n    };\n    const timer = setTimeout(settle, waitMs);\n    const done = () => {\n      clearTimeout(timer);\n      settle();\n    };\n    void cache.setOwner(ownerId).then(done, done);\n    return () => {\n      live = false;\n      clearTimeout(timer);\n    };\n  }, [cache, ownerId, waitMs]);\n  const [mountedOffline] = useState(() => cache !== null && isOffline());\n  return mountedOffline && ownerId !== null && readFor !== ownerId;\n}\n\n/** The provider's offline snapshots: when a thread on screen was captured, if it opened offline. */\nexport type AthenaOfflineSnapshots = Pick<\n  DurableThreadSnapshotCache,\n  'offlineSeedAt' | 'subscribeOfflineSeeds'\n>;\n\nexport const AthenaOfflineSnapshotsContext = createContext<AthenaOfflineSnapshots | null>(null);\n\nconst noSubscription = (): (() => void) => () => undefined;\nconst serverSnapshot = (): number | null => null;\n\n/**\n * When the transcript `threadId` shows was captured, if it opened from this device while Athena\n * could not be reached; `null` once the thread's own state arrives, outside an `offlineHistory`\n * provider, or for a new chat.\n */\nexport function useAthenaOfflineSnapshotAt(threadId: string | undefined): number | null {\n  const snapshots = useContext(AthenaOfflineSnapshotsContext);\n  return useSyncExternalStore(\n    snapshots ? (listener) => snapshots.subscribeOfflineSeeds(listener) : noSubscription,\n    () => (snapshots && threadId ? snapshots.offlineSeedAt(threadId) : null),\n    serverSnapshot,\n  );\n}\n\nexport function formatOfflineSnapshotTime(at: number): string {\n  return new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' }).format(at);\n}\n\nexport interface OfflineSnapshotBannerProps {\n  /** Applied to the outer wrapper (host padding); the banner itself is width-capped inside it. */\n  className?: string;\n}\n\n/**\n * Above a conversation that opened from this device while Athena can't be reached: what is shown\n * is the conversation as it was then, not live. Renders nothing otherwise.\n */\nexport const OfflineSnapshotBanner: FC<OfflineSnapshotBannerProps> = ({ className }) => {\n  const at = useAthenaOfflineSnapshotAt(useAthenaThreadId());\n  if (at === null) return null;\n  return (\n    <div className={className}>\n      <div\n        role=\"status\"\n        className={cn(\n          'mx-auto flex w-full max-w-(--thread-max-width) items-center gap-2 rounded-md border px-3 py-2 text-xs',\n          'border-border bg-muted text-muted-foreground',\n        )}\n      >\n        <CloudOffIcon className=\"size-3.5 shrink-0\" aria-hidden />\n        <span>Offline · this conversation as of {formatOfflineSnapshotTime(at)}</span>\n      </div>\n    </div>\n  );\n};\n"],"names":[],"mappings":";;;;;AAwCO,MAAM,gCAAgC;AAQtC,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AACX,GAKY;AACV,QAAM,CAAC,SAAS,UAAU,IAAI,SAAoC,MAAS;AAC3E,YAAU,MAAM;AACd,QAAI,CAAC,MAAO;AACZ,QAAI,OAAO;AACX,UAAM,SAAS,MAAM;AACnB,UAAI,iBAAiB,OAAO;AAAA,IAC9B;AACA,UAAM,QAAQ,WAAW,QAAQ,MAAM;AACvC,UAAM,OAAO,MAAM;AACjB,mBAAa,KAAK;AAClB,aAAA;AAAA,IACF;AACA,SAAK,MAAM,SAAS,OAAO,EAAE,KAAK,MAAM,IAAI;AAC5C,WAAO,MAAM;AACX,aAAO;AACP,mBAAa,KAAK;AAAA,IACpB;AAAA,EACF,GAAG,CAAC,OAAO,SAAS,MAAM,CAAC;AAC3B,QAAM,CAAC,cAAc,IAAI,SAAS,MAAM,UAAU,QAAQ,WAAW;AACrE,SAAO,kBAAkB,YAAY,QAAQ,YAAY;AAC3D;AAQO,MAAM,gCAAgC,cAA6C,IAAI;AAE9F,MAAM,iBAAiB,MAAoB,MAAM;AACjD,MAAM,iBAAiB,MAAqB;AAOrC,SAAS,2BAA2B,UAA6C;AACtF,QAAM,YAAY,WAAW,6BAA6B;AAC1D,SAAO;AAAA,IACL,YAAY,CAAC,aAAa,UAAU,sBAAsB,QAAQ,IAAI;AAAA,IACtE,MAAO,aAAa,WAAW,UAAU,cAAc,QAAQ,IAAI;AAAA,IACnE;AAAA,EAAA;AAEJ;AAEO,SAAS,0BAA0B,IAAoB;AAC5D,SAAO,IAAI,KAAK,eAAe,QAAW,EAAE,WAAW,UAAU,WAAW,QAAA,CAAS,EAAE,OAAO,EAAE;AAClG;AAWO,MAAM,wBAAwD,CAAC,EAAE,gBAAgB;AACtF,QAAM,KAAK,2BAA2B,mBAAmB;AACzD,MAAI,OAAO,KAAM,QAAO;AACxB,SACE,oBAAC,SAAI,WACH,UAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,MAAK;AAAA,MACL,WAAW;AAAA,QACT;AAAA,QACA;AAAA,MAAA;AAAA,MAGF,UAAA;AAAA,QAAA,oBAAC,cAAA,EAAa,WAAU,qBAAoB,eAAW,MAAC;AAAA,6BACvD,QAAA,EAAK,UAAA;AAAA,UAAA;AAAA,UAAmC,0BAA0B,EAAE;AAAA,QAAA,EAAA,CAAE;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA,GAE3E;AAEJ;"}

package/dist/provider/AthenaProvider.cjs

@@ -3,6 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
 const react$1 = require("@assistant-ui/react");
 const react = require("react");
+const offlineHistory = require("../offline/offline-history.cjs");
+const chatOutbox = require("../offline/chat-outbox.cjs");
 const athenaUrls = require("../lib/athena-urls.cjs");
 const mint = require("../collab/mint.cjs");
 const auth = require("../runtime/auth.cjs");
@@ -11,7 +13,10 @@ const AthenaCredentialSourceContext = require("../auth/AthenaCredentialSourceCon
 const credentialSource = require("../auth/credential-source.cjs");
 const authRefusalRestart = require("../runtime/auth-refusal-restart.cjs");
 const useAthenaStatewireRuntime = require("../runtime/useAthenaStatewireRuntime.cjs");
+const statewireSessionKey = require("../runtime/statewire-session-key.cjs");
+const statewireSessionLane = require("../runtime/statewire-session-lane.cjs");
 const statewireLifecycle = require("../runtime/statewire-lifecycle.cjs");
+const credentialRenewal = require("../runtime/credential-renewal.cjs");
 const statewireRunConfig = require("../runtime/statewire-run-config.cjs");
 const statewireThreadConfigLane = require("../runtime/statewire-thread-config-lane.cjs");
 const mintThreadId = require("../threads/mint-thread-id.cjs");
@@ -36,10 +41,15 @@ const assetPanelStore = require("../assets/asset-panel-store.cjs");
 const index = require("../theme/index.cjs");
 const themeStyleContext = require("./theme-style-context.cjs");
 const PostHogProvider = require("./PostHogProvider.cjs");
+const threadSnapshotMirror = require("../agent-runtime/src/thread-snapshot-mirror.cjs");
+const durableThreadSnapshotCache = require("../agent-runtime/src/durable-thread-snapshot-cache.cjs");
 const threadSnapshotCache = require("../agent-runtime/src/thread-snapshot-cache.cjs");
+const chatOutboxAttachments = require("../agent-runtime/src/chat-outbox-attachments.cjs");
 const toolOutputs = require("../agent-runtime/src/tool-outputs.cjs");
 const threadStatus = require("../agent-runtime/src/thread-status.cjs");
+const useDeepAgentChatOutbox = require("../agent-runtime/src/use-deep-agent-chat-outbox.cjs");
 const useDeepAgentConfig = require("../agent-runtime/src/use-deep-agent-config.cjs");
+const chatOutboxSignals = require("../agent-runtime/src/chat-outbox-signals.cjs");
 const resolveTokenOverride = ({
   config,
   token
@@ -101,6 +111,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;
@@ -135,8 +146,12 @@ function AthenaStatewireRuntimeMount({
   appId,
   extraRunConfig,
   snapshotCache,
-  toolOutputs: toolOutputs2
+  toolOutputs: toolOutputs2,
+  chatOutbox: chatOutbox2 = null,
+  sessionLane,
+  subagentLaneHistory
 }) {
+  const outboxRef = react.useRef(null);
   const [lifecycle, dispatchLifecycle] = react.useReducer(
     statewireLifecycle.statewireLifecycleReducer,
     statewireLifecycle.initialStatewireLifecycle
@@ -165,6 +180,7 @@ function AthenaStatewireRuntimeMount({
     extraRunConfig,
     snapshotCache,
     toolOutputs: toolOutputs2,
+    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.
@@ -178,6 +194,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) => {
@@ -185,6 +205,64 @@ function AthenaStatewireRuntimeMount({
       setServerLane((previous) => statewireServerLaneContext.nextServerLane({ previous, config }));
     }
   });
+  const lanePending = statewireSessionKey.statewireSessionPrincipal(react.useContext(AthenaAuthContext.AthenaAuthContext)) === null;
+  react.useEffect(() => {
+    sessionLane.setPending(lanePending);
+  }, [sessionLane, lanePending]);
+  const connectionRef = react.useRef(lifecycle.connection);
+  connectionRef.current = lifecycle.connection;
+  const [connectionListeners] = react.useState(() => /* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    for (const listener of connectionListeners) listener();
+  }, [lifecycle.connection, connectionListeners]);
+  const [channelReachability] = react.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] = react.useState(chatOutboxSignals.browserOnlineSignal);
+  const hostReachability = chatOutbox2 == null ? void 0 : chatOutbox2.reachability;
+  const reachability = react.useMemo(
+    () => chatOutboxSignals.allChatOutboxSignals(hostReachability ?? browserOnline, channelReachability),
+    [hostReachability, browserOnline, channelReachability]
+  );
+  const [defaultForeground] = react.useState(chatOutboxSignals.documentVisibleSignal);
+  const composerHandoff$1 = composerHandoff.useComposerHandoffStore();
+  const outbox = useDeepAgentChatOutbox.useDeepAgentChatOutbox({
+    client,
+    threadId,
+    isNewChat,
+    store: (chatOutbox2 == null ? void 0 : chatOutbox2.store) ?? null,
+    reachability,
+    foreground: (chatOutbox2 == null ? void 0 : chatOutbox2.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$1 && entry.attachments) {
+        composerHandoff.rememberRestoredAttachments({
+          store: composerHandoff$1,
+          threadId,
+          attachments: entry.attachments
+        });
+      }
+    },
+    ...(chatOutbox2 == null ? void 0 : chatOutbox2.openThread) && { openThread: chatOutbox2.openThread },
+    ...(chatOutbox2 == null ? void 0 : chatOutbox2.checkAttachments) && { checkAttachments: chatOutbox2.checkAttachments },
+    enabled: chatOutbox2 !== null
+  });
+  outboxRef.current = outbox;
   authRefusalRestart.useRestartAfterAuthRefusal({
     connection: lifecycle.connection,
     reconnect: lifecycle.reconnect
@@ -218,9 +296,10 @@ function AthenaStatewireRuntimeMount({
       client,
       lifecycle: lifecycleValue,
       serverLane,
-      threadConfig
+      threadConfig,
+      outbox
     }),
-    [threadId, isNewChat, client, lifecycleValue, serverLane, threadConfig]
+    [threadId, isNewChat, client, lifecycleValue, serverLane, threadConfig, outbox]
   );
   react.useLayoutEffect(() => {
     onPublish(snapshot);
@@ -320,7 +399,7 @@ function AthenaStatewireStandalone({
       published.threadId
     ),
     /* @__PURE__ */ jsxRuntime.jsx(ComposerHandoffDrain, {}),
-    /* @__PURE__ */ jsxRuntime.jsx(chatModeContext.AthenaChatModeSelectionContext.Provider, { value: chatModeSelection, children })
+    /* @__PURE__ */ jsxRuntime.jsx(useDeepAgentChatOutbox.DeepAgentChatOutboxContext.Provider, { value: published.outbox, children: /* @__PURE__ */ jsxRuntime.jsx(chatModeContext.AthenaChatModeSelectionContext.Provider, { value: chatModeSelection, children }) })
   ] }) }) }) }) }) }) }) }) });
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(
@@ -354,6 +433,7 @@ function AthenaStatewireWithThreadList({
   initialThreadId,
   includePullRequests,
   additionalListAppIds,
+  offlineList,
   ...standaloneProps
 }) {
   return /* @__PURE__ */ jsxRuntime.jsx(
@@ -368,6 +448,7 @@ function AthenaStatewireWithThreadList({
       additionalListAppIds,
       initialThreadId,
       includePullRequests,
+      offlineList,
       snapshotCache: standaloneProps.snapshotCache,
       children: /* @__PURE__ */ jsxRuntime.jsx(
         AthenaStatewireActiveThreadHost,
@@ -387,15 +468,25 @@ function AthenaStatewireWithThreadList({
 }
 function AthenaStatewireActiveThreadHost({
   children,
+  chatOutbox: chatOutbox2,
   ...standaloneProps
 }) {
   const list = statewireThreadList.useAthenaStatewireThreadList();
+  const selectThread = list == null ? void 0 : list.selectThread;
+  const outboxHost = react.useMemo(
+    () => chatOutbox2 && !chatOutbox2.openThread && selectThread ? {
+      ...chatOutbox2,
+      openThread: ({ threadId, newChat }) => selectThread(threadId, { isNew: newChat })
+    } : chatOutbox2,
+    [chatOutbox2, selectThread]
+  );
   if (!list) return null;
   return /* @__PURE__ */ jsxRuntime.jsxs(
     AthenaStatewireStandalone,
     {
       threadId: list.activeThreadId,
       threadList: { isNewChat: list.isNewChat },
+      chatOutbox: outboxHost,
       ...standaloneProps,
       children: [
         /* @__PURE__ */ jsxRuntime.jsx(statewireThreadList.StatewireThreadTitlePoller, {}),
@@ -448,7 +539,10 @@ function AthenaProvider({
   posthog: posthogProp,
   debug,
   onDiagnostic,
-  onError
+  onError,
+  offlineHistory: offlineHistory$1,
+  chatOutbox: chatOutbox$1,
+  subagentLaneHistory = false
 }) {
   var _a;
   const agentAssetId = statewireRunConfig.resolveAgentProp({ agent });
@@ -525,7 +619,87 @@ function AthenaProvider({
   });
   const authContext = react.useContext(AthenaAuthContext.AthenaAuthContext);
   const authProviderToken = (authContext == null ? void 0 : authContext.accessToken) ?? null;
-  const [snapshotCache] = react.useState(() => threadSnapshotCache.createDeepAgentThreadSnapshotCache());
+  const offlineHistoryRef = react.useRef(offlineHistory$1);
+  offlineHistoryRef.current = offlineHistory$1;
+  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] = react.useState(
+    () => offlineHistory$1 ? threadSnapshotMirror.createThreadSnapshotMirror({
+      getKey: (ownerId) => {
+        const host = offlineHistoryRef.current;
+        return host && host.ownerId === ownerId ? host.getKey() : Promise.resolve(null);
+      }
+    }) : null
+  );
+  const [durableSnapshotCache] = react.useState(
+    () => offlineMirror ? durableThreadSnapshotCache.createDurableThreadSnapshotCache({ mirror: offlineMirror, isOffline: isOfflineNow }) : null
+  );
+  const [snapshotCache] = react.useState(
+    () => durableSnapshotCache ?? threadSnapshotCache.createDeepAgentThreadSnapshotCache()
+  );
+  const chatOutboxRef = react.useRef(chatOutbox$1);
+  chatOutboxRef.current = chatOutbox$1;
+  const chatOutboxOwnerId = (chatOutbox$1 == null ? void 0 : chatOutbox$1.ownerId) ?? null;
+  const chatOutboxStore = react.useMemo(() => {
+    const host = chatOutboxRef.current;
+    return host && host.ownerId === chatOutboxOwnerId ? chatOutbox.chatOutboxStoreFor(host) : null;
+  }, [chatOutboxOwnerId]);
+  react.useEffect(() => {
+    if (chatOutbox$1) chatOutbox.chatOutboxStoreFor(chatOutbox$1);
+  }, [chatOutbox$1]);
+  const chatOutboxReachability = chatOutbox$1 == null ? void 0 : chatOutbox$1.reachability;
+  const chatOutboxForeground = chatOutbox$1 == null ? void 0 : chatOutbox$1.foreground;
+  const chatOutboxOpenThread = chatOutbox$1 == null ? void 0 : chatOutbox$1.openThread;
+  const outboxCheckAuthRef = react.useRef({});
+  const outboxCheckBackendRef = react.useRef("");
+  const [checkChatOutboxAttachments] = react.useState(
+    () => chatOutboxAttachments.createChatOutboxAttachmentCheck({
+      readAsset: (assetId) => credentialRenewal.sendWithCredentialRenewal(
+        outboxCheckAuthRef.current,
+        (headers) => fetch(`${outboxCheckBackendRef.current}${chatOutboxAttachments.chatOutboxAttachmentPath(assetId)}`, {
+          method: "GET",
+          headers,
+          signal: AbortSignal.timeout(CHAT_OUTBOX_ATTACHMENT_READ_TIMEOUT_MS)
+        })
+      )
+    })
+  );
+  const chatOutboxHost = react.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$1 == null ? void 0 : offlineHistory$1.ownerId) ?? null;
+  const awaitingKeptSnapshots = offlineHistory.useKeptSnapshotsGate({
+    cache: durableSnapshotCache,
+    ownerId: offlineOwnerId,
+    isOffline: isOfflineNow
+  });
+  const offlineSnapshots = react.useMemo(
+    () => durableSnapshotCache ? {
+      offlineSeedAt: (threadId) => durableSnapshotCache.offlineSeedAt(threadId),
+      subscribeOfflineSeeds: (listener) => durableSnapshotCache.subscribeOfflineSeeds(listener)
+    } : null,
+    [durableSnapshotCache]
+  );
+  const offlineList = react.useMemo(
+    () => offlineMirror && offlineOwnerId ? { mirror: offlineMirror, ownerId: offlineOwnerId } : void 0,
+    [offlineMirror, offlineOwnerId]
+  );
   const [composerHandoff$1] = react.useState(composerHandoff.createComposerHandoffStore);
   const [toolOutputs$1] = react.useState(() => toolOutputs.createDeepAgentToolOutputStore());
   const [historyStore] = react.useState(statewireHistoryContext.createStatewireHistoryStore);
@@ -533,8 +707,21 @@ function AthenaProvider({
   react.useEffect(() => {
     snapshotCache.clear();
     toolOutputs$1.clear();
-    composerHandoff.clearComposerHandoff({ store: composerHandoff$1, reason: "the signed-in identity changed" });
-  }, [snapshotCache, toolOutputs$1, composerHandoff$1, principal, configuredApiKey]);
+  }, [snapshotCache, toolOutputs$1, principal, configuredApiKey]);
+  const sessionPrincipal = statewireSessionKey.statewireSessionPrincipal(authContext);
+  const [sessionLane] = react.useState(
+    () => statewireSessionLane.createStatewireSessionLaneGate({ pending: sessionPrincipal === null })
+  );
+  const handoffIdentityRef = react.useRef(null);
+  react.useEffect(() => {
+    if (sessionPrincipal === null) return;
+    const identity = JSON.stringify([sessionPrincipal, configuredApiKey ?? null]);
+    const previous = handoffIdentityRef.current;
+    handoffIdentityRef.current = identity;
+    if (previous !== null && previous !== identity) {
+      composerHandoff.clearComposerHandoff({ store: composerHandoff$1, reason: "the signed-in identity changed" });
+    }
+  }, [composerHandoff$1, sessionPrincipal, configuredApiKey]);
   react.useEffect(
     () => () => composerHandoff.clearComposerHandoff({ store: composerHandoff$1, reason: "the chat provider unmounted" }),
     [composerHandoff$1]
@@ -558,6 +745,12 @@ function AthenaProvider({
   const effectiveBackendUrl = mint.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 ?? athenaUrls.deriveAthenaAppUrl({ apiUrl: effectiveApiUrl, backendUrl: effectiveBackendUrl }) ?? environmentUrls.appUrl;
   if (!bridge.ready) {
@@ -598,6 +791,9 @@ function AthenaProvider({
     snapshotCache,
     toolOutputs: toolOutputs$1,
     historyStore,
+    chatOutbox: chatOutboxHost,
+    sessionLane,
+    subagentLaneHistory,
     linkClicks,
     citationLinks
   };
@@ -608,6 +804,7 @@ function AthenaProvider({
       initialThreadId: threadIdProp,
       includePullRequests: threadListIncludePullRequests,
       additionalListAppIds: threadListAdditionalAppIds,
+      offlineList,
       children
     }
   ) : (
@@ -629,7 +826,7 @@ function AthenaProvider({
     {
       className: themeStyleVars ? "athena-sdk athena-themed" : "athena-sdk",
       style: themeStyleVars,
-      children: /* @__PURE__ */ jsxRuntime.jsx(PostHogProvider.PostHogProvider, { config: posthogConfig, children: /* @__PURE__ */ jsxRuntime.jsx(composerHandoff.ComposerHandoffContext.Provider, { value: composerHandoff$1, children: /* @__PURE__ */ jsxRuntime.jsx(themeStyleContext.AthenaThemeStyleContext.Provider, { value: themeStyleVars, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaCredentialSourceContext.AthenaCredentialSourceContext.Provider, { value: credentials, children: /* @__PURE__ */ jsxRuntime.jsx(agentSelectionContext.AthenaAgentSelectionContext.Provider, { value: agentSelection, children: inner }) }) }) }) })
+      children: /* @__PURE__ */ jsxRuntime.jsx(PostHogProvider.PostHogProvider, { config: posthogConfig, children: /* @__PURE__ */ jsxRuntime.jsx(composerHandoff.ComposerHandoffContext.Provider, { value: composerHandoff$1, children: /* @__PURE__ */ jsxRuntime.jsx(statewireSessionLane.StatewireSessionLaneContext.Provider, { value: sessionLane, children: /* @__PURE__ */ jsxRuntime.jsx(themeStyleContext.AthenaThemeStyleContext.Provider, { value: themeStyleVars, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaCredentialSourceContext.AthenaCredentialSourceContext.Provider, { value: credentials, children: /* @__PURE__ */ jsxRuntime.jsx(agentSelectionContext.AthenaAgentSelectionContext.Provider, { value: agentSelection, children: /* @__PURE__ */ jsxRuntime.jsx(offlineHistory.AthenaOfflineSnapshotsContext.Provider, { value: offlineSnapshots, children: awaitingKeptSnapshots ? null : inner }) }) }) }) }) }) })
     }
   );
 }