@athenaintel/react 0.41.3 → 0.42.2

package/dist/offline/chat-outbox.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const chatOutboxStore = require("../agent-runtime/src/chat-outbox-store.cjs");
+const chatOutbox = require("../agent-runtime/src/chat-outbox.cjs");
+const ownerStores = /* @__PURE__ */ new Map();
+function keylessHost(ownerId) {
+  return { ownerId, getKey: async () => null };
+}
+function ownerStore(ownerId, host) {
+  let owner = ownerStores.get(ownerId);
+  if (!owner) {
+    const current = { current: host ?? keylessHost(ownerId) };
+    owner = {
+      host: current,
+      store: chatOutboxStore.createIndexedDbChatOutboxStore({
+        ownerId,
+        getKey: (_ownerId, purpose) => current.current.getKey(purpose)
+      })
+    };
+    ownerStores.set(ownerId, owner);
+  }
+  if (host) owner.host.current = host;
+  return owner.store;
+}
+function chatOutboxStoreFor(host) {
+  return ownerStore(host.ownerId, host);
+}
+function countChatOutboxMessages(ownerId) {
+  return ownerStore(ownerId).count();
+}
+function subscribeChatOutbox(ownerId, listener) {
+  return ownerStore(ownerId).subscribe(listener);
+}
+async function listChatOutboxMessages(ownerId, now = Date.now()) {
+  const records = await ownerStore(ownerId).listAll();
+  return records.map(({ entry, claim, failure, memoryOnly }) => ({
+    id: entry.id,
+    threadId: entry.threadId,
+    text: entry.text,
+    newChat: entry.newChat,
+    status: failure ? "failed" : claim && now - claim.at < chatOutbox.CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > chatOutbox.CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
+    inMemory: memoryOnly === true
+  }));
+}
+function clearChatOutbox(ownerId) {
+  return ownerStore(ownerId).clear();
+}
+function clearUnopenableChatOutbox(ownerId) {
+  return chatOutboxStore.createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+}
+exports.chatOutboxStoreFor = chatOutboxStoreFor;
+exports.clearChatOutbox = clearChatOutbox;
+exports.clearUnopenableChatOutbox = clearUnopenableChatOutbox;
+exports.countChatOutboxMessages = countChatOutboxMessages;
+exports.listChatOutboxMessages = listChatOutboxMessages;
+exports.subscribeChatOutbox = subscribeChatOutbox;
+//# sourceMappingURL=chat-outbox.cjs.map

package/dist/offline/chat-outbox.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox.cjs","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  CHAT_OUTBOX_CLAIM_LEASE_MS,\n  type ChatOutboxKeyPurpose,\n  type ChatOutboxSignal,\n  type ChatOutboxStore,\n  createIndexedDbChatOutboxStore,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike\n *   the chat history's, this key guards the only copy of what someone wrote: a host must never\n *   replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\ninterface OwnerStore {\n  store: ChatOutboxStore;\n  /** The latest host for this owner: the store asks it for the key. */\n  host: { current: AthenaChatOutbox };\n}\n\n// process-local: one store per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one change bus and one memory of the messages this device could\n// not keep: a thread switch or a closed tab never loses them, and a sign-out counts them.\nconst ownerStores = new Map<string, OwnerStore>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction ownerStore(ownerId: string, host?: AthenaChatOutbox): ChatOutboxStore {\n  let owner = ownerStores.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    owner = {\n      host: current,\n      store: createIndexedDbChatOutboxStore({\n        ownerId,\n        getKey: (_ownerId, purpose) => current.current.getKey(purpose),\n      }),\n    };\n    ownerStores.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner.store;\n}\n\n/** The page's chat outbox store for `host`'s owner, made on first use. */\nexport function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore {\n  return ownerStore(host.ownerId, host);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without opening them. Rejects when the\n * device's records cannot be counted at all.\n */\nexport function countChatOutboxMessages(ownerId: string): Promise<number> {\n  return ownerStore(ownerId).count();\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStore(ownerId).subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its\n   * conversation now (a window's claim on it still holds), waiting for the person (it waited more\n   * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const records = await ownerStore(ownerId).listAll();\n  return records.map(({ entry, claim, failure, memoryOnly }) => ({\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: failure\n      ? 'failed'\n      : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory: memoryOnly === true,\n  }));\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport function clearChatOutbox(ownerId: string): Promise<void> {\n  return ownerStore(ownerId).clear();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();\n}\n"],"names":["createIndexedDbChatOutboxStore","CHAT_OUTBOX_CLAIM_LEASE_MS","CHAT_OUTBOX_ASK_AFTER_MS"],"mappings":";;;;AAiDA,MAAM,kCAAkB,IAAA;AAGxB,SAAS,YAAY,SAAmC;AACtD,SAAO,EAAE,SAAS,QAAQ,YAAY,KAAA;AACxC;AAEA,SAAS,WAAW,SAAiB,MAA0C;AAC7E,MAAI,QAAQ,YAAY,IAAI,OAAO;AACnC,MAAI,CAAC,OAAO;AACV,UAAM,UAAU,EAAE,SAAS,QAAQ,YAAY,OAAO,EAAA;AACtD,YAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAOA,gBAAAA,+BAA+B;AAAA,QACpC;AAAA,QACA,QAAQ,CAAC,UAAU,YAAY,QAAQ,QAAQ,OAAO,OAAO;AAAA,MAAA,CAC9D;AAAA,IAAA;AAEH,gBAAY,IAAI,SAAS,KAAK;AAAA,EAChC;AACA,MAAI,KAAM,OAAM,KAAK,UAAU;AAC/B,SAAO,MAAM;AACf;AAGO,SAAS,mBAAmB,MAAyC;AAC1E,SAAO,WAAW,KAAK,SAAS,IAAI;AACtC;AAOO,SAAS,wBAAwB,SAAkC;AACxE,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,oBAAoB,SAAiB,UAAkC;AACrF,SAAO,WAAW,OAAO,EAAE,UAAU,QAAQ;AAC/C;AA0BA,eAAsB,uBACpB,SACA,MAAc,KAAK,OACkB;AACrC,QAAM,UAAU,MAAM,WAAW,OAAO,EAAE,QAAA;AAC1C,SAAO,QAAQ,IAAI,CAAC,EAAE,OAAO,OAAO,SAAS,kBAAkB;AAAA,IAC7D,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,QAAQ,UACJ,WACA,SAAS,MAAM,MAAM,KAAKC,WAAAA,6BACxB,YACA,MAAM,MAAM,WAAWC,WAAAA,2BACrB,QACA;AAAA,IACR,UAAU,eAAe;AAAA,EAAA,EACzB;AACJ;AAGO,SAAS,gBAAgB,SAAgC;AAC9D,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,0BAA0B,SAAgC;AACxE,SAAOF,gBAAAA,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;;;;;;;"}

package/dist/offline/chat-outbox.d.ts

@@ -0,0 +1,80 @@
+import { type ChatOutboxKeyPurpose, type ChatOutboxSignal, type ChatOutboxStore } from '../agent-runtime/src/index';
+/**
+ * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's
+ * key, and are sent once Athena is back while the app is in front, after a countdown the person
+ * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).
+ * Without it a send goes to the transport as before.
+ *
+ * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's
+ *   messages are never shown or sent: each owner's are sealed under their own key.
+ * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,
+ *   never made for this), `write` keeps a new message (only while the deployment lets devices keep
+ *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike
+ *   the chat history's, this key guards the only copy of what someone wrote: a host must never
+ *   replace or drop it except at a sign-out the person chose.
+ * - `reachability` says Athena can be reached: the host's own model (the device online AND agora
+ *   answering a health read, as Midas's main process decides it), by default the browser being
+ *   online. Either way a conversation whose own channel keeps failing to connect counts as out of
+ *   reach too.
+ * - `foreground` says the app is in front; by default a visible document. A desktop host passes
+ *   `windowInFrontSignal()` (visible and focused).
+ * - `openThread` opens another of the person's conversations the tray lists as holding waiting
+ *   messages (`newChat`: one that never started). Without it, a provider with a thread list
+ *   switches to it; otherwise the tray names it without Open.
+ */
+export interface AthenaChatOutbox {
+    ownerId: string;
+    getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;
+    reachability?: ChatOutboxSignal;
+    foreground?: ChatOutboxSignal;
+    openThread?: (target: {
+        threadId: string;
+        newChat: boolean;
+    }) => void;
+}
+/** The page's chat outbox store for `host`'s owner, made on first use. */
+export declare function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore;
+/**
+ * How many messages wait for `ownerId` (kept on the device, including records this build cannot
+ * open, and waiting in this page's memory), counted without opening them. Rejects when the
+ * device's records cannot be counted at all.
+ */
+export declare function countChatOutboxMessages(ownerId: string): Promise<number>;
+/**
+ * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's
+ * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many
+ * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.
+ */
+export declare function subscribeChatOutbox(ownerId: string, listener: () => void): () => void;
+/** A message waiting in an owner's outbox, as a host lists it (its "Waiting to sync" list). */
+export interface ChatOutboxMessageSummary {
+    id: string;
+    threadId: string;
+    /** The text as it will be sent. */
+    text: string;
+    /** Typed into a chat that had never started. */
+    newChat: boolean;
+    /**
+     * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its
+     * conversation now (a window's claim on it still holds), waiting for the person (it waited more
+     * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).
+     */
+    status: 'waiting' | 'sending' | 'ask' | 'failed';
+    /** Kept only in this page's memory: this device could not keep it. */
+    inMemory: boolean;
+}
+/**
+ * The messages waiting for `ownerId` that this page can open (oldest first), each with where it
+ * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.
+ * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with
+ * `countChatOutboxMessages`.
+ */
+export declare function listChatOutboxMessages(ownerId: string, now?: number): Promise<ChatOutboxMessageSummary[]>;
+/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */
+export declare function clearChatOutbox(ownerId: string): Promise<void>;
+/**
+ * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's
+ * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the
+ * page could delete the records), so nothing can ever open them and they must not be counted.
+ */
+export declare function clearUnopenableChatOutbox(ownerId: string): Promise<void>;

package/dist/offline/chat-outbox.js

@@ -0,0 +1,57 @@
+import { createIndexedDbChatOutboxStore } from "../agent-runtime/src/chat-outbox-store.js";
+import { CHAT_OUTBOX_CLAIM_LEASE_MS, CHAT_OUTBOX_ASK_AFTER_MS } from "../agent-runtime/src/chat-outbox.js";
+const ownerStores = /* @__PURE__ */ new Map();
+function keylessHost(ownerId) {
+  return { ownerId, getKey: async () => null };
+}
+function ownerStore(ownerId, host) {
+  let owner = ownerStores.get(ownerId);
+  if (!owner) {
+    const current = { current: host ?? keylessHost(ownerId) };
+    owner = {
+      host: current,
+      store: createIndexedDbChatOutboxStore({
+        ownerId,
+        getKey: (_ownerId, purpose) => current.current.getKey(purpose)
+      })
+    };
+    ownerStores.set(ownerId, owner);
+  }
+  if (host) owner.host.current = host;
+  return owner.store;
+}
+function chatOutboxStoreFor(host) {
+  return ownerStore(host.ownerId, host);
+}
+function countChatOutboxMessages(ownerId) {
+  return ownerStore(ownerId).count();
+}
+function subscribeChatOutbox(ownerId, listener) {
+  return ownerStore(ownerId).subscribe(listener);
+}
+async function listChatOutboxMessages(ownerId, now = Date.now()) {
+  const records = await ownerStore(ownerId).listAll();
+  return records.map(({ entry, claim, failure, memoryOnly }) => ({
+    id: entry.id,
+    threadId: entry.threadId,
+    text: entry.text,
+    newChat: entry.newChat,
+    status: failure ? "failed" : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
+    inMemory: memoryOnly === true
+  }));
+}
+function clearChatOutbox(ownerId) {
+  return ownerStore(ownerId).clear();
+}
+function clearUnopenableChatOutbox(ownerId) {
+  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+}
+export {
+  chatOutboxStoreFor,
+  clearChatOutbox,
+  clearUnopenableChatOutbox,
+  countChatOutboxMessages,
+  listChatOutboxMessages,
+  subscribeChatOutbox
+};
+//# sourceMappingURL=chat-outbox.js.map

package/dist/offline/chat-outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox.js","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  CHAT_OUTBOX_CLAIM_LEASE_MS,\n  type ChatOutboxKeyPurpose,\n  type ChatOutboxSignal,\n  type ChatOutboxStore,\n  createIndexedDbChatOutboxStore,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike\n *   the chat history's, this key guards the only copy of what someone wrote: a host must never\n *   replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\ninterface OwnerStore {\n  store: ChatOutboxStore;\n  /** The latest host for this owner: the store asks it for the key. */\n  host: { current: AthenaChatOutbox };\n}\n\n// process-local: one store per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one change bus and one memory of the messages this device could\n// not keep: a thread switch or a closed tab never loses them, and a sign-out counts them.\nconst ownerStores = new Map<string, OwnerStore>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction ownerStore(ownerId: string, host?: AthenaChatOutbox): ChatOutboxStore {\n  let owner = ownerStores.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    owner = {\n      host: current,\n      store: createIndexedDbChatOutboxStore({\n        ownerId,\n        getKey: (_ownerId, purpose) => current.current.getKey(purpose),\n      }),\n    };\n    ownerStores.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner.store;\n}\n\n/** The page's chat outbox store for `host`'s owner, made on first use. */\nexport function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore {\n  return ownerStore(host.ownerId, host);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without opening them. Rejects when the\n * device's records cannot be counted at all.\n */\nexport function countChatOutboxMessages(ownerId: string): Promise<number> {\n  return ownerStore(ownerId).count();\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStore(ownerId).subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its\n   * conversation now (a window's claim on it still holds), waiting for the person (it waited more\n   * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const records = await ownerStore(ownerId).listAll();\n  return records.map(({ entry, claim, failure, memoryOnly }) => ({\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: failure\n      ? 'failed'\n      : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory: memoryOnly === true,\n  }));\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport function clearChatOutbox(ownerId: string): Promise<void> {\n  return ownerStore(ownerId).clear();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();\n}\n"],"names":[],"mappings":";;AAiDA,MAAM,kCAAkB,IAAA;AAGxB,SAAS,YAAY,SAAmC;AACtD,SAAO,EAAE,SAAS,QAAQ,YAAY,KAAA;AACxC;AAEA,SAAS,WAAW,SAAiB,MAA0C;AAC7E,MAAI,QAAQ,YAAY,IAAI,OAAO;AACnC,MAAI,CAAC,OAAO;AACV,UAAM,UAAU,EAAE,SAAS,QAAQ,YAAY,OAAO,EAAA;AACtD,YAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAO,+BAA+B;AAAA,QACpC;AAAA,QACA,QAAQ,CAAC,UAAU,YAAY,QAAQ,QAAQ,OAAO,OAAO;AAAA,MAAA,CAC9D;AAAA,IAAA;AAEH,gBAAY,IAAI,SAAS,KAAK;AAAA,EAChC;AACA,MAAI,KAAM,OAAM,KAAK,UAAU;AAC/B,SAAO,MAAM;AACf;AAGO,SAAS,mBAAmB,MAAyC;AAC1E,SAAO,WAAW,KAAK,SAAS,IAAI;AACtC;AAOO,SAAS,wBAAwB,SAAkC;AACxE,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,oBAAoB,SAAiB,UAAkC;AACrF,SAAO,WAAW,OAAO,EAAE,UAAU,QAAQ;AAC/C;AA0BA,eAAsB,uBACpB,SACA,MAAc,KAAK,OACkB;AACrC,QAAM,UAAU,MAAM,WAAW,OAAO,EAAE,QAAA;AAC1C,SAAO,QAAQ,IAAI,CAAC,EAAE,OAAO,OAAO,SAAS,kBAAkB;AAAA,IAC7D,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,QAAQ,UACJ,WACA,SAAS,MAAM,MAAM,KAAK,6BACxB,YACA,MAAM,MAAM,WAAW,2BACrB,QACA;AAAA,IACR,UAAU,eAAe;AAAA,EAAA,EACzB;AACJ;AAGO,SAAS,gBAAgB,SAAgC;AAC9D,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,0BAA0B,SAAgC;AACxE,SAAO,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;"}

package/dist/offline/offline-history.d.ts

@@ -1,4 +1,4 @@
-import type { DurableThreadSnapshotCache } from '@athenaintel/agent-runtime';
+import type { DurableThreadSnapshotCache } from '../agent-runtime/src/index';
 import { type FC } from 'react';
 /**
  * Opt-in: keep the chat's recent conversations, and the session list, on this device, sealed with

package/dist/provider/AthenaProvider.cjs

@@ -4,6 +4,7 @@ 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");
@@ -12,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");
@@ -40,9 +44,12 @@ 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
@@ -104,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;
@@ -138,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
@@ -168,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.
@@ -181,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) => {
@@ -188,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
@@ -221,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);
@@ -323,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(
@@ -392,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, {}),
@@ -454,7 +540,9 @@ function AthenaProvider({
   debug,
   onDiagnostic,
   onError,
-  offlineHistory: offlineHistory$1
+  offlineHistory: offlineHistory$1,
+  chatOutbox: chatOutbox$1,
+  subagentLaneHistory = false
 }) {
   var _a;
   const agentAssetId = statewireRunConfig.resolveAgentProp({ agent });
@@ -551,6 +639,50 @@ function AthenaProvider({
   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,
@@ -575,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]
@@ -600,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) {
@@ -640,6 +791,9 @@ function AthenaProvider({
     snapshotCache,
     toolOutputs: toolOutputs$1,
     historyStore,
+    chatOutbox: chatOutboxHost,
+    sessionLane,
+    subagentLaneHistory,
     linkClicks,
     citationLinks
   };
@@ -672,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: /* @__PURE__ */ jsxRuntime.jsx(offlineHistory.AthenaOfflineSnapshotsContext.Provider, { value: offlineSnapshots, children: awaitingKeptSnapshots ? null : 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 }) }) }) }) }) }) })
     }
   );
 }