@athenaintel/react 0.40.0 → 0.40.2

package/README.md

@@ -561,7 +561,25 @@ the loaded unread rows; **Dismiss** uses
 session — a dismissed session comes back with its next message).
 `InboxButton` is a bell with the unread count (`useAthenaInboxUnreadCount`,
 the Unread tab's first page: `50+` past one page) that opens the inbox in a
-popover.
+popover. Each tab shows its count once its list has answered, and nothing
+before.
+
+### What counts as read
+
+`AthenaChat` marks the session it shows read for the viewer, as Athena's own
+chat does, wherever the session was opened from (`SessionList`, the inbox, a
+`?session_id=` link): once the chat is in front of the person (its window,
+a pop-out's included, visible and focused, and the chat itself on screen, not
+hidden behind a maximized workbench), the session's history is on screen, no
+run is going and its row is unread, for a second.
+The write is the provider's `setReadState` with the row's `updatedAt`, so
+every list under the provider flips at once and the next message shows the
+session unread again. A message that arrives while the person watches is
+marked too (a running session is marked when its run ends, never per
+streamed chunk); a read session is never written; and a session the person
+marks unread from a list stays unread until something new arrives or they
+open it again. A host that draws its own transcript instead of `AthenaChat`
+calls `setReadState` itself.
 
 ### Server filters and older servers
 
@@ -789,6 +807,22 @@ Both use the same bearer / API key as session creation. The full recipe
 template skill `voice-session-guide.md`. `createAthenaVoiceSession` is also
 exported if you hold the bridge state yourself.
 
+## What's new in 0.40.2
+
+**An answer that is still arriving is never called stalled.** The grouped turn header said "Nothing new for 31s" in amber whenever a turn's answer, or the agent's thinking, had streamed for more than thirty seconds, because its stall clock restarted only when a new part or tool step arrived. It now restarts whenever anything streams, an answer or thinking growing included, so the stall tone keeps its meaning: nothing has streamed for thirty seconds while the run waits on the model. A running tool still never gets the stall tone (0.40.1).
+
+Nothing to change in your app.
+
+## What's new in 0.40.1
+
+**The session you are looking at is marked read.** In `enableThreadList` mode, `AthenaChat` now writes the viewer's read receipt for the session it shows, as Athena's own chat does: once the chat is in front of the person (its window, a pop-out's included, visible and focused, and the chat itself on screen, not hidden behind a maximized workbench), the session's history is on screen, no run is going and its row is unread, for a second. A session opened from `SessionList`, the inbox or a `?session_id=` link used to stay unread for good (only the inbox's own open, its Mark all read and the sessions page toggle wrote the receipt), so unread dots and the inbox's Unread count only grew. The write is the provider's `setReadState` (`POST /api/conversations/threads/read-state`, the route the inbox already used) with the row's `updatedAt`, so every list flips at once and the next message shows the session unread again. A message that arrives while the person watches is marked too, with at most one write per message; nothing polls, a read session is never written, and a session the person marks unread stays unread until something new arrives or they open it again. See [What counts as read](#what-counts-as-read).
+
+**The inbox shows a tab's count once it has one.** The All and Unread tabs counted their rows before their first page answered ("All 0 · Unread 14" for a moment). A tab now shows no count until its list has answered.
+
+**A running tool is never called stalled.** While the agent runs a long command, a build or a test suite (or a tool such as Python execution that shows only its streaming placeholder while it works), the turn header no longer adds "Nothing new for 1m 00s" in amber, and the line under an ungrouped turn keeps the tool's verb with a neutral counter ("Running a command… · 1m 04s") instead of "Still working — nothing new". The stall tone stays for a quiet stream that waits on the model.
+
+Nothing to change in your app.
+
 ## What's new in 0.40.0
 
 **`AthenaChat` shows an agent's UI test recording.** When an agent with the UI Testing toolkit checks a change in its computer's browser, `test_recording_stop` now renders a report card: the recording's title, "N passed · M failed" (with "· K untested" when a test was never checked), each test with its ✓ / ✗ assertions and what the agent saw (a failed assertion is tinted red, a test with no assertion reads "Not checked"), the summary, and the edited video. Every test's start time is a chapter: click it and the video plays from there (an assertion's time works the same way). A **Watch in Athena** link opens the asset in Athena. The card stays in the conversation instead of folding into the turn's collapsed steps. `test_recording_start` and `test_recording_mark` each render one compact row ("Recording started", "Test", "Pass", "Fail", "Note" with the time in the recording), and their collapsed steps read "Started recording "…"", "Started test: It should …", "Passed: …", "Failed: …".
@@ -1934,7 +1968,7 @@ Your own portals can read the same context: `usePortalContainer()` returns the p
 
 - **The agent's sentences stay visible.** Every text part the agent writes before its last tool call ("I'll find your workstation, then check origin/staging.", "Started. Now I'll compare.") renders in the transcript, in order, as it streams. Only the work between two sentences folds: each run of tool calls and reasoning becomes one collapsed step row. The answer (the text after the last tool call) renders below, as before; no text renders twice.
 - **Each step says what it did.** A collapsed row names the step in progress, else the last one it took — "Ran `git log -1 origin/staging`", "Read `live_audio.py`", "Edited `upstream.py`" with "+4 −1", "Found 3 assets for "workstation"", "jevin-box is running", "Viewed pull request #43093", "Updated plan (3/7 done)" — with "+2 more" when the row folds several. Opening it lists every step, and "Show tool details" reveals that row's tool UIs.
-- **The header counts the turn.** "Working for 1m 12s" while it runs, "Worked for 2m 30s · Used 7 tools" once done (from the messages' own server stamps), "Waiting for you" on an approval. After thirty seconds without a streamed change the header adds "Nothing new for 42s" in amber.
+- **The header counts the turn.** "Working for 1m 12s" while it runs, "Worked for 2m 30s · Used 7 tools" once done (from the messages' own server stamps), "Waiting for you" on an approval. After thirty seconds in which the model has streamed nothing the header adds "Nothing new for 42s" in amber — but never while a tool call is still running: a command, a build or a test run streams nothing for minutes while it works, so its step row says it is running and the header goes on counting the turn. With `groupToolCalls={false}` the line under the turn keeps the running tool's verb and a neutral counter ("Running a command… · 1m 04s") the same way.
 
 The transcript is `SuperGroupingTranscript` from `@athenaintel/react/super-grouping`; it takes the same renderer and host slots as `SuperGroupingCard` (which keeps the single-card layout for hosts that mount it). `splitTurnSegments`, `readTurnTiming` and `formatWorkDuration` are exported for hosts that lay a turn out themselves.
 

package/dist/chat/AthenaChat.cjs

@@ -49,6 +49,7 @@ const lucideReact = require("lucide-react");
 const react$1 = require("react");
 const threadIdContext = require("../threads/thread-id-context.cjs");
 const statewireThreadList = require("../threads/statewire-thread-list.cjs");
+const markViewedThreadRead = require("../threads/mark-viewed-thread-read.cjs");
 const FileUploadButton = require("../composer/FileUploadButton.cjs");
 const ComposerQuotePreview = require("../composer/ComposerQuotePreview.cjs");
 const ComposerAttachmentPreview = require("../composer/ComposerAttachmentPreview.cjs");
@@ -252,7 +253,10 @@ const AthenaChat = ({
   return /* @__PURE__ */ jsxRuntime.jsx(AthenaChatDefaultComponentsContext.Provider, { value: defaultComponentsContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaChatErrorBoundary.AthenaChatErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(toolFallback.ToolFallbackAppearanceProvider, { appearance: "thread", children: /* @__PURE__ */ jsxRuntime.jsx(apiClient.MentionAuthCtx.Provider, { value: mentionAuth, children: /* @__PURE__ */ jsxRuntime.jsx(
     chatThreadShell.ChatThreadShell,
     {
-      overlay: /* @__PURE__ */ jsxRuntime.jsx(threadLoadingOverlay.ThreadLoadingOverlay, {}),
+      overlay: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(threadLoadingOverlay.ThreadLoadingOverlay, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(markViewedThreadRead.MarkViewedThreadRead, {})
+      ] }),
       panelClassName: cnfast.cn(
         "aui-root aui-thread-root @container relative flex h-full flex-col bg-background",
         className
@@ -598,21 +602,22 @@ const MessageError = () => /* @__PURE__ */ jsxRuntime.jsx(react.MessagePrimitive
     }
   ) })
 ] }) });
-function useSecondsSince(resetKey) {
+function useSecondsSince({ resetKey, ticking = true }) {
   const [seconds, setSeconds] = react$1.useState(0);
   react$1.useEffect(() => {
     setSeconds(0);
+    if (!ticking) return;
     const startedAt = Date.now();
     const timer = setInterval(() => {
       setSeconds(Math.floor((Date.now() - startedAt) / 1e3));
     }, 1e3);
     return () => clearInterval(timer);
-  }, [resetKey]);
+  }, [resetKey, ticking]);
   return seconds;
 }
-const RunStatusLine = ({ verb, resetKey, className }) => {
-  const seconds = useSecondsSince(resetKey);
-  const stalled = seconds >= runActivity.RUN_ACTIVITY_STALL_SECONDS;
+const RunStatusLine = ({ verb, resetKey, toolCallInFlight = false, className }) => {
+  const seconds = useSecondsSince({ resetKey });
+  const stalled = runActivity.isRunActivityStalled({ seconds, toolCallInFlight });
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
@@ -638,7 +643,7 @@ const RunStatusLine = ({ verb, resetKey, className }) => {
           {
             "aria-hidden": "true",
             className: cnfast.cn("tabular-nums", stalled && "text-amber-600 dark:text-amber-400"),
-            children: runActivity.runActivityLabel(seconds, verb)
+            children: runActivity.runActivityLabel({ seconds, verb, stalled })
           }
         ),
         /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-live": "polite", className: "sr-only", children: stalled ? "Assistant is still working; nothing new for over thirty seconds." : `${verb}…` })
@@ -668,13 +673,22 @@ const AthenaMessageActivityIndicator = () => {
   });
   const activityKey = react.useAuiState((s) => runActivity.runActivityKey(s.message.parts));
   const verb = react.useAuiState((s) => runActivity.runActivityVerb(s.message.parts));
+  const toolCallInFlight = react.useAuiState((s) => runActivity.isToolCallInFlight(s.message.parts));
   if (!isRunning || activityKey === null) return null;
-  return /* @__PURE__ */ jsxRuntime.jsx(RunStatusLine, { verb: verb ?? "Working", resetKey: activityKey });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    RunStatusLine,
+    {
+      verb: verb ?? "Working",
+      resetKey: activityKey,
+      toolCallInFlight
+    }
+  );
 };
 const AthenaGroupedRunMeta = () => {
-  const activityKey = react.useAuiState((s) => runActivity.runActivityKey(s.message.parts));
-  const seconds = useSecondsSince(activityKey ?? "thinking");
-  const stalled = seconds >= runActivity.RUN_ACTIVITY_STALL_SECONDS;
+  const progressKey = react.useAuiState((s) => runActivity.runProgressKey(s.message.parts));
+  const toolCallInFlight = react.useAuiState((s) => runActivity.isToolCallInFlight(s.message.parts));
+  const seconds = useSecondsSince({ resetKey: progressKey, ticking: !toolCallInFlight });
+  const stalled = runActivity.isRunActivityStalled({ seconds, toolCallInFlight });
   if (!stalled) return null;
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "span",