@athenaintel/react 0.41.3 → 0.42.1

package/dist/index.cjs

@@ -39,10 +39,12 @@ const statewireThreadList = require("./threads/statewire-thread-list.cjs");
 const WaitingOnYouBanner = require("./chat/WaitingOnYouBanner.cjs");
 const wakeMarker = require("./chat-ui/messages/wake-marker.cjs");
 const offlineHistory = require("./offline/offline-history.cjs");
+const chatOutbox = require("./offline/chat-outbox.cjs");
 const tiptapText = require("./chat/tiptap-text.cjs");
 const athenaCitationLinks = require("./chat/athena-citation-links.cjs");
 const tooltipIconButton = require("./chat/tooltip-icon-button.cjs");
 const toolUis = require("./tools/tool-uis.cjs");
+const subagentTaskToolUi = require("./tools/subagent-task-tool-ui.cjs");
 const primitives = require("./tools/primitives.cjs");
 const miscToolUis = require("./tools/misc-tool-uis.cjs");
 const toolIcons = require("./tools/tool-icons.cjs");
@@ -134,6 +136,8 @@ const toolMetadata = require("./agent-runtime/src/tool-metadata.cjs");
 const githubWakeEvent = require("./agent-runtime/src/github-wake-event.cjs");
 const threadExtras = require("./agent-runtime/src/thread-extras.cjs");
 const toolAppearance = require("./tools/tool-appearance.cjs");
+const subagents = require("./agent-runtime/src/subagents.cjs");
+const chatOutboxSignals = require("./agent-runtime/src/chat-outbox-signals.cjs");
 exports.ATHENA_REACT_SDK_VERSION = version.ATHENA_REACT_SDK_VERSION;
 exports.athenaDiagnostics = athenaDiagnostics.athenaDiagnostics;
 exports.installAthenaDiagnosticsGlobal = athenaDiagnostics.installAthenaDiagnosticsGlobal;
@@ -197,6 +201,7 @@ exports.workedDurationMs = turnTiming.workedDurationMs;
 exports.defaultGetToolGroupKey = toolkitMap.defaultGetToolGroupKey;
 exports.StatewireApprovalCard = StatewireApprovalCard.StatewireApprovalCard;
 exports.useStatewireApprovalRequest = useStatewireApprovalRequest.useStatewireApprovalRequest;
+exports.useStatewireApprovalWait = useStatewireApprovalRequest.useStatewireApprovalWait;
 exports.useAthenaRunLive = useAthenaRunLive.useAthenaRunLive;
 exports.StatewireHistoryEdge = statewireHistoryEdge.StatewireHistoryEdge;
 exports.ThreadLoadingOverlay = threadLoadingOverlay.ThreadLoadingOverlay;
@@ -224,6 +229,11 @@ exports.OFFLINE_SNAPSHOT_READ_WAIT_MS = offlineHistory.OFFLINE_SNAPSHOT_READ_WAI
 exports.OfflineSnapshotBanner = offlineHistory.OfflineSnapshotBanner;
 exports.formatOfflineSnapshotTime = offlineHistory.formatOfflineSnapshotTime;
 exports.useAthenaOfflineSnapshotAt = offlineHistory.useAthenaOfflineSnapshotAt;
+exports.clearChatOutbox = chatOutbox.clearChatOutbox;
+exports.clearUnopenableChatOutbox = chatOutbox.clearUnopenableChatOutbox;
+exports.countChatOutboxMessages = chatOutbox.countChatOutboxMessages;
+exports.listChatOutboxMessages = chatOutbox.listChatOutboxMessages;
+exports.subscribeChatOutbox = chatOutbox.subscribeChatOutbox;
 exports.TiptapText = tiptapText.TiptapText;
 exports.isAthenaCitationUrl = athenaCitationLinks.isAthenaCitationUrl;
 exports.parseAthenaCitationLink = athenaCitationLinks.parseAthenaCitationLink;
@@ -249,6 +259,7 @@ exports.UpdateSheetRangeToolUI = toolUis.UpdateSheetRangeToolUI;
 exports.WebSearchToolUI = toolUis.WebSearchToolUI;
 exports.createAssetToolUI = toolUis.createAssetToolUI;
 exports.resetAssetAutoOpen = toolUis.resetAssetAutoOpen;
+exports.SubagentTaskToolUI = subagentTaskToolUi.SubagentTaskToolUI;
 exports.CopyToolSpecButton = primitives.CopyToolSpecButton;
 exports.ExpandableSection = primitives.ExpandableSection;
 exports.ToolCard = primitives.ToolCard;
@@ -539,4 +550,6 @@ exports.isGithubWakeMessage = githubWakeEvent.isGithubWakeMessage;
 exports.readGithubWakeEvent = githubWakeEvent.readGithubWakeEvent;
 exports.hasStatewireThreadExtras = threadExtras.hasStatewireThreadExtras;
 exports.useToolAppearance = toolAppearance.useToolAppearance;
+exports.useTurnToolCallsAwaitingApproval = subagents.useTurnToolCallsAwaitingApproval;
+exports.windowInFrontSignal = chatOutboxSignals.windowInFrontSignal;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export { StatewireApprovalCard } from './chat/StatewireApprovalCard';
 export type { StatewireApprovalCardProps, StatewireApprovalEditorContext, StatewireApprovalRequestContext, } from './chat/StatewireApprovalCard';
 export { useStatewireApprovalRequest } from './chat/use-statewire-approval-request';
 export type { StatewireApprovalRequest, StatewireInterruptPredicate, UseStatewireApprovalRequestOptions, } from './chat/use-statewire-approval-request';
+export { useStatewireApprovalWait } from './chat/use-statewire-approval-request';
+export type { StatewireApprovalWait } from './chat/use-statewire-approval-request';
+export { useTurnToolCallsAwaitingApproval } from './agent-runtime/src/index';
 export { useAthenaRunLive } from './chat/use-athena-run-live';
 export { StatewireHistoryEdge } from './chat-ui/thread/statewire-history-edge';
 export type { StatewireHistoryEdgeProps } from './chat-ui/thread/statewire-history-edge';
@@ -37,8 +40,8 @@ export { StatewireConnectionBanner, StatewireErrorBanner, } from './chat/statewi
 export type { StatewireErrorBannerProps } from './chat/statewire-banners';
 export { RUN_START_REFUSAL_FALLBACK_MESSAGE, StatewireRunRefusalNotice, } from './chat/StatewireRunRefusalNotice';
 export type { StatewireRunRefusalNoticeProps } from './chat/StatewireRunRefusalNotice';
-export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, readRunStartRefusal, } from '@athenaintel/agent-runtime';
-export type { RunStartRefusal } from '@athenaintel/agent-runtime';
+export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, readRunStartRefusal, } from './agent-runtime/src/index';
+export type { RunStartRefusal } from './agent-runtime/src/index';
 export { StatewireClientToolBridge } from './chat/StatewireClientToolBridge';
 export { collectStatewireClientTools, statewireClientToolWireEntries, } from './chat/statewire-client-tools';
 export type { StatewireClientTool } from './chat/statewire-client-tools';
@@ -53,6 +56,9 @@ export { WakeMarkerCard, WakeMarkerMessage } from './chat-ui/messages/wake-marke
 export type { WakeMarkerCardProps } from './chat-ui/messages/wake-marker';
 export { formatOfflineSnapshotTime, OFFLINE_SNAPSHOT_READ_WAIT_MS, OfflineSnapshotBanner, useAthenaOfflineSnapshotAt, } from './offline/offline-history';
 export type { AthenaOfflineHistory, OfflineSnapshotBannerProps, } from './offline/offline-history';
+export { type AthenaChatOutbox, clearChatOutbox, clearUnopenableChatOutbox, type ChatOutboxMessageSummary, countChatOutboxMessages, listChatOutboxMessages, subscribeChatOutbox, } from './offline/chat-outbox';
+/** For an `AthenaChatOutbox` host: the key purposes, and the desktop's "window in front" signal. */
+export { type ChatOutboxKeyPurpose, windowInFrontSignal } from './agent-runtime/src/index';
 export { asHitlApproval, hasStatewireThreadExtras, HITL_PENDING_RESUME_GRACE_MS, isPendingInterrupt, readInterruptMessage, } from './chat/statewire-approval';
 export type { HitlApprovalPayload } from './chat/statewire-approval';
 export { TiptapText } from './chat/tiptap-text';
@@ -62,12 +68,13 @@ export { TooltipIconButton } from './chat/tooltip-icon-button';
 export type { TooltipIconButtonProps } from './chat/tooltip-icon-button';
 export { TOOL_UI_REGISTRY } from './tools/tool-uis';
 export { WebSearchToolUI, BrowseToolUI, OpenBrowserToolUI, EmailSearchToolUI, CreateDocumentToolUI, CreateSheetToolUI, CreatePresentationToolUI, CreateNotebookToolUI, RunPythonCodeToolUI, OpenAssetToolUI, CreateEmailDraftToolUI, UpdateSheetRangeToolUI, DescribeDatabaseToolUI, ListDatabaseTablesToolUI, GetDatabaseTableSchemaToolUI, RunSqlToolUI, createAssetToolUI, resetAssetAutoOpen, } from './tools/tool-uis';
+export { SubagentTaskToolUI } from './tools/subagent-task-tool-ui';
 export { CopyToolSpecButton, ExpandableSection, formatToolName, normalizeResult, ToolCard, truncate, } from './tools/primitives';
 export type { ToolStatus } from './tools/primitives';
 export { InstallPackageToolUI } from './tools/misc-tool-uis';
 export { TOOL_ICONS, toolIcon } from './tools/tool-icons';
-export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultSuccess, resultMessage, toolActiveLabel, toolCompletedLabel, } from '@athenaintel/agent-runtime';
-export type { ToolDisplayMeta, ToolIconKey, ToolResultClassification, } from '@athenaintel/agent-runtime';
+export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultSuccess, resultMessage, toolActiveLabel, toolCompletedLabel, } from './agent-runtime/src/index';
+export type { ToolDisplayMeta, ToolIconKey, ToolResultClassification, } from './agent-runtime/src/index';
 export { HiddenWriteTodosToolUI, PlanStepMarker, WriteTodosToolUI, parseTodoPlan, } from './tools/write-todos-tool-ui';
 export { useLatestTodoPlan } from './tools/todo-plan-store';
 export type { LatestTodoPlan } from './tools/todo-plan-store';
@@ -145,8 +152,8 @@ export type { SessionStatusChip, SessionStatusTone, SessionsColumn, SessionsColu
 export type { ThreadReadStateTarget } from './threads/use-thread-read-state';
 export { groupSessions, orderedPullRequests, pullRequestChip, pullRequestChipState, sessionIndicator, sessionListGroupOf, sessionOriginBadge, sessionOriginLabel, sessionSecondaryLine, WEB_APP_ORIGIN_LABEL, } from './threads/session-list-model';
 export type { PullRequestChip, PullRequestChipState, SessionIndicator, SessionLineTone, SessionListGroup, SessionListSection, SessionOriginBadges, SessionSecondaryLine, } from './threads/session-list-model';
-export { deriveConversationAttention, githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent, } from '@athenaintel/agent-runtime';
-export type { ConversationAttention, ConversationAttentionSource, ConversationPullRequest, ConversationSummary, ConversationWake, GithubWakeEvent, } from '@athenaintel/agent-runtime';
+export { deriveConversationAttention, githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent, } from './agent-runtime/src/index';
+export type { ConversationAttention, ConversationAttentionSource, ConversationPullRequest, ConversationSummary, ConversationWake, GithubWakeEvent, } from './agent-runtime/src/index';
 export type { ThreadFavoriteResponse, ThreadInboxDismissResponse, ThreadListFilterBody, ThreadListResponse, ThreadPullRequest, ThreadRenameResponse, ThreadSummary, ThreadWake, } from './threads/api';
 export { useRefreshThreadList } from './threads/statewire-thread-list';
 export { useAthenaThreadId, AthenaThreadIdContext, useAthenaStatewireThreadId, } from './threads/thread-id-context';

package/dist/index.js

@@ -20,7 +20,7 @@ import { splitTurnSegments } from "./chat/super-grouping/turn-segments.js";
 import { formatWorkDuration, readTurnTiming, workedDurationMs } from "./chat/super-grouping/turn-timing.js";
 import { defaultGetToolGroupKey } from "./chat/super-grouping/toolkit-map.js";
 import { StatewireApprovalCard } from "./chat/StatewireApprovalCard.js";
-import { useStatewireApprovalRequest } from "./chat/use-statewire-approval-request.js";
+import { useStatewireApprovalRequest, useStatewireApprovalWait } from "./chat/use-statewire-approval-request.js";
 import { useAthenaRunLive } from "./chat/use-athena-run-live.js";
 import { StatewireHistoryEdge } from "./chat-ui/thread/statewire-history-edge.js";
 import { ThreadLoadingOverlay } from "./chat-ui/thread/thread-loading-overlay.js";
@@ -37,10 +37,12 @@ import { threadSummaryFromConversation, useAthenaStatewireThreadList, useRefresh
 import { WaitingOnYouBanner, WaitingOnYouBannerView } from "./chat/WaitingOnYouBanner.js";
 import { WakeMarkerCard, WakeMarkerMessage } from "./chat-ui/messages/wake-marker.js";
 import { OFFLINE_SNAPSHOT_READ_WAIT_MS, OfflineSnapshotBanner, formatOfflineSnapshotTime, useAthenaOfflineSnapshotAt } from "./offline/offline-history.js";
+import { clearChatOutbox, clearUnopenableChatOutbox, countChatOutboxMessages, listChatOutboxMessages, subscribeChatOutbox } from "./offline/chat-outbox.js";
 import { TiptapText } from "./chat/tiptap-text.js";
 import { isAthenaCitationUrl, parseAthenaCitationLink, useAthenaCitationLinkHandler, useAthenaLinkClickHandler } from "./chat/athena-citation-links.js";
 import { TooltipIconButton } from "./chat/tooltip-icon-button.js";
 import { BrowseToolUI, CreateDocumentToolUI, CreateEmailDraftToolUI, CreateNotebookToolUI, CreatePresentationToolUI, CreateSheetToolUI, DescribeDatabaseToolUI, EmailSearchToolUI, GetDatabaseTableSchemaToolUI, ListDatabaseTablesToolUI, OpenAssetToolUI, OpenBrowserToolUI, RunPythonCodeToolUI, RunSqlToolUI, TOOL_UI_REGISTRY, UpdateSheetRangeToolUI, WebSearchToolUI, createAssetToolUI, resetAssetAutoOpen } from "./tools/tool-uis.js";
+import { SubagentTaskToolUI } from "./tools/subagent-task-tool-ui.js";
 import { CopyToolSpecButton, ExpandableSection, ToolCard, normalizeResult, truncate } from "./tools/primitives.js";
 import { InstallPackageToolUI } from "./tools/misc-tool-uis.js";
 import { TOOL_ICONS, toolIcon } from "./tools/tool-icons.js";
@@ -132,6 +134,8 @@ import { describeToolArgs, formatToolName, getToolDisplayMeta, toolActiveLabel,
 import { githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent } from "./agent-runtime/src/github-wake-event.js";
 import { hasStatewireThreadExtras } from "./agent-runtime/src/thread-extras.js";
 import { useToolAppearance } from "./tools/tool-appearance.js";
+import { useTurnToolCallsAwaitingApproval } from "./agent-runtime/src/subagents.js";
+import { windowInFrontSignal } from "./agent-runtime/src/chat-outbox-signals.js";
 export {
   ATHENA_REACT_SDK_VERSION,
   ATHENA_REPO_SEARCH_PATH,
@@ -252,6 +256,7 @@ export {
   StatewireHistoryEdge,
   StatewireQueuedMessages,
   StatewireRunRefusalNotice,
+  SubagentTaskToolUI,
   SuperGroupingCard,
   SuperGroupingFinalText,
   SuperGroupingProvider,
@@ -322,6 +327,8 @@ export {
   channelLabel,
   classifyToolResult,
   clearAutoOpenedAssets,
+  clearChatOutbox,
+  clearUnopenableChatOutbox,
   cn,
   collectAssetTitles,
   collectStatewireClientTools,
@@ -335,6 +342,7 @@ export {
   conversationDisplayTitle,
   conversationSummaryFromIndexEntry,
   countActivityTools,
+  countChatOutboxMessages,
   createAssetToolUI,
   createAthenaSpacesUrl,
   createAttachmentStore,
@@ -405,6 +413,7 @@ export {
   isThreadFavoriteUnavailableError,
   isThreadRenameUnavailableError,
   isToolResultSuccess,
+  listChatOutboxMessages,
   listThreads,
   liveDesktopViewerUrl,
   matchesSessionsQuery,
@@ -462,6 +471,7 @@ export {
   splitSheetPrefix,
   splitTurnSegments,
   statewireClientToolWireEntries,
+  subscribeChatOutbox,
   summarizeToolCall,
   taskProgress,
   themeToStyleVars,
@@ -527,10 +537,13 @@ export {
   useSessionWorkbench,
   useSessionWorkbenchWorkspace,
   useStatewireApprovalRequest,
+  useStatewireApprovalWait,
   useStatewireConversationHistory,
   useStatewireHistory,
   useStatewireToolOutputs,
   useToolAppearance,
+  useTurnToolCallsAwaitingApproval,
+  windowInFrontSignal,
   withCaptureGateBypass,
   workedDurationMs,
   workspaceComputers,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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