@athenaintel/react 0.28.0 → 0.30.0

package/dist/threads/statewire-thread-list.d.ts

@@ -1,7 +1,9 @@
-import { type ConversationAttention, type ConversationAttentionSource, type ConversationPullRequest, type ConversationSummary, type ConversationWake, type DeepAgentThreadSnapshotCache } from '@athenaintel/agent-runtime';
+import { type ConversationAttention, type ConversationAttentionSource, type ConversationIndexEntry, type ConversationListFilter, type ConversationPullRequest, type ConversationSummary, type ConversationWake, type DeepAgentThreadSnapshotCache } from '@athenaintel/agent-runtime';
 import { type ReactNode } from 'react';
 import { type AthenaStatewireTokenGetter } from '../runtime/statewire-auth-headers';
+import { type CredentialResolver } from '../runtime/credential-renewal';
 import { type ThreadFavoriteTarget } from './use-thread-favorite';
+import { type ThreadReadStateTarget } from './use-thread-read-state';
 import { type ThreadRenameTarget } from './use-thread-rename';
 /**
  * One row of the thread list — the fields a Devin-style session list renders
@@ -44,6 +46,15 @@ export interface AthenaStatewireThreadSummary {
     lastWake: ConversationWake | null;
     /** ISO 8601 timestamp of the last update (the list's sort key). */
     updatedAt: string;
+    /** ISO 8601 creation time; `null` when the list did not report it. */
+    createdAt?: string | null;
+    /** The session's last message, for a preview line (the inbox excerpt). */
+    preview?: string | null;
+    /** The collab agent the session started as, and its channel (`null`: the default channel). */
+    collabAgentId?: string | null;
+    collabChannelId?: string | null;
+    /** Whether the viewer started the session (`false`: shared with them); `null` when not reported. */
+    createdByMe?: boolean | null;
 }
 /**
  * Thread-list state. The list is the persisted Agora session list; the ACTIVE
@@ -150,6 +161,16 @@ export interface AthenaStatewireThreadListState {
      * 404 / 405: `SessionList` then offers no Archive action.
      */
     archiveAvailable: boolean;
+    /**
+     * Mark a session read or unread for the viewer
+     * (`POST /api/conversations/threads/read-state`). The row flips at once in
+     * every list under the provider (`SessionList`, `SessionsPage`, `Inbox`);
+     * the server's answer is written back, and a failure restores the previous
+     * state. Same-thread writes are serialized like the pin's.
+     */
+    setReadState: (target: ThreadReadStateTarget) => void;
+    /** The sessions whose read-state write is in flight. */
+    readStatePendingThreadIds: ReadonlySet<string>;
     /**
      * Where titles come from. `'index'` once the signed-in user's live
      * conversation index has replicated — titles and newly created threads then
@@ -168,7 +189,65 @@ export declare function useRefreshThreadList(): (() => void) | null;
  * Project one contract row onto the thread-list row. Exported for hosts (and
  * tests) that build rows from a `ConversationSummary` of their own.
  */
+/**
+ * The threads the conversation index knows that the fetched list does not show yet, and that have
+ * not prompted a refresh before: each warrants one refresh of the list. Only threads of the apps
+ * the list shows count (its `appId` and `additionalAppIds`); with neither, every app's do.
+ * Exported for tests.
+ */
+export declare function indexedThreadsToRefreshFor({ entries, listedThreadIds, refreshedThreadIds, appId, additionalAppIds, }: {
+    entries: ReadonlyArray<{
+        thread_id: string;
+        app_id: string | null;
+    }>;
+    listedThreadIds: ReadonlySet<string>;
+    refreshedThreadIds: ReadonlySet<string>;
+    appId: string | undefined;
+    additionalAppIds: readonly string[];
+}): string[];
 export declare function threadSummaryFromConversation(conversation: ConversationSummary): AthenaStatewireThreadSummary;
+/**
+ * Fold the pushed conversation index into fetched rows: each row with an
+ * index entry takes its pushed fields through the shared
+ * `summaryFromConversationIndexEntry` (titles, lifecycle, attention), while
+ * what the index never carries (pull requests, the last wake, who started
+ * it) keeps the fetched value. A pushed title that normalizes to nothing
+ * falls back to the fetched one. Exported for tests.
+ */
+export declare function foldConversationIndex(conversations: readonly ConversationSummary[], indexByThread: ReadonlyMap<string, ConversationIndexEntry>): ConversationSummary[];
+/**
+ * What the thread-list provider shares with the other lists mounted under it
+ * (`SessionsPage`, `Inbox`): the credential, the live conversation index and
+ * the optimistic overrides (pin, title, read state, archived rows), so every
+ * list folds the same pushes and shows the same in-flight writes. Internal —
+ * hosts use `useAthenaSessions`.
+ */
+export interface AthenaSessionsLiveState {
+    backendUrl: string;
+    getAuth: CredentialResolver<{
+        apiKey?: string;
+        token?: string | null;
+    }>;
+    principal: string;
+    hasAuth: boolean;
+    includePullRequests: boolean;
+    /** The provider list's cache scope (backend, principal, auth, PR opt-in). */
+    scopeKey: string;
+    /**
+     * Advances whenever the host's credential changes (a swapped API key or
+     * token, a scoped credential for another workspace under the same
+     * principal), so caches keyed on it are never read with another credential.
+     */
+    credentialGeneration: number;
+    /** The app scope the provider lists (`appId` / `additionalListAppIds`). */
+    baseFilter: ConversationListFilter;
+    indexByThread: ReadonlyMap<string, ConversationIndexEntry>;
+    /** `null` until the index has replicated (or without one). */
+    indexEntries: readonly ConversationIndexEntry[] | null;
+    /** Layer the in-flight writes over rows and drop archived ones. */
+    applyOverrides: (rows: readonly ConversationSummary[]) => ConversationSummary[];
+}
+export declare const AthenaSessionsLiveContext: import("react").Context<AthenaSessionsLiveState | null>;
 /**
  * Provides the statewire thread-list state, with an SDK-scoped QueryClient so
  * consumers do not need their own QueryClientProvider. `syncUrl` (the
@@ -180,13 +259,15 @@ export declare function threadSummaryFromConversation(conversation: Conversation
  * the runtime seeds a switched-to thread from — which `prefetchThread` warms;
  * without it prefetching is a no-op.
  */
-export declare function AthenaStatewireThreadListProvider({ backendUrl, syncUrl, apiKey, token, getToken, appId, initialThreadId, includePullRequests, snapshotCache, children, }: {
+export declare function AthenaStatewireThreadListProvider({ backendUrl, syncUrl, apiKey, token, getToken, appId, additionalListAppIds, initialThreadId, includePullRequests, snapshotCache, children, }: {
     backendUrl: string;
     syncUrl?: string;
     apiKey?: string;
     token?: string | null;
     getToken?: AthenaStatewireTokenGetter;
     appId?: string;
+    /** Other client apps whose sessions the list shows too (a union with `appId`). */
+    additionalListAppIds?: readonly string[];
     initialThreadId?: string;
     includePullRequests?: boolean;
     snapshotCache?: DeepAgentThreadSnapshotCache;

package/dist/threads/statewire-thread-list.js

@@ -1,5 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { QueryClient, QueryClientProvider, useQuery } from "@tanstack/react-query";
+import { QueryClient, QueryClientProvider, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useAuiState } from "@assistant-ui/react";
 import { useContext, createContext, useState, useRef, useCallback, useMemo, useEffect } from "react";
 import { AthenaAuthContext } from "../auth/AthenaAuthContext.js";
@@ -15,10 +15,11 @@ import { useRestartAfterAuthRefusal } from "../runtime/auth-refusal-restart.js";
 import { withCredentialRenewal } from "../runtime/credential-renewal.js";
 import { useThreadArchive } from "./use-thread-archive.js";
 import { useThreadFavorite, withFavoriteOverrides, withFavoriteOverride } from "./use-thread-favorite.js";
+import { useThreadReadState, withReadStateOverrides } from "./use-thread-read-state.js";
 import { useThreadRename, withTitleOverrides, withTitleOverride } from "./use-thread-rename.js";
-import { deriveConversationAttention, summaryFromConversationIndexEntry } from "../packages/agent-runtime/src/conversation-list.js";
-import { useConversationList } from "../packages/agent-runtime/src/use-conversation-list.js";
-import { useConversationIndex, conversationIndexUrlFromStatewireUrl } from "../packages/agent-runtime/src/conversation-index.js";
+import { deriveConversationAttention, summaryFromConversationIndexEntry, patchConversationListCaches, removeConversationFromListCaches } from "../agent-runtime/src/conversation-list.js";
+import { useConversationList } from "../agent-runtime/src/use-conversation-list.js";
+import { useConversationIndex, conversationIndexUrlFromStatewireUrl } from "../agent-runtime/src/conversation-index.js";
 const AthenaStatewireThreadListContext = createContext(null);
 function useAthenaStatewireThreadList() {
   return useContext(AthenaStatewireThreadListContext);
@@ -27,6 +28,16 @@ function useRefreshThreadList() {
   var _a;
   return ((_a = useAthenaStatewireThreadList()) == null ? void 0 : _a.refresh) ?? null;
 }
+function indexedThreadsToRefreshFor({
+  entries,
+  listedThreadIds,
+  refreshedThreadIds,
+  appId,
+  additionalAppIds
+}) {
+  const shownAppIds = appId || additionalAppIds.length > 0 ? /* @__PURE__ */ new Set([...appId ? [appId] : [], ...additionalAppIds]) : null;
+  return entries.filter((entry) => !shownAppIds || shownAppIds.has(entry.app_id ?? "")).map((entry) => entry.thread_id).filter((threadId) => !listedThreadIds.has(threadId) && !refreshedThreadIds.has(threadId));
+}
 function threadSummaryFromConversation(conversation) {
   return {
     id: conversation.threadId,
@@ -43,9 +54,23 @@ function threadSummaryFromConversation(conversation) {
     triggerType: conversation.triggerType,
     pullRequests: conversation.pullRequests ?? null,
     lastWake: conversation.lastWake ?? null,
-    updatedAt: conversation.updatedAt
+    updatedAt: conversation.updatedAt,
+    createdAt: conversation.createdAt,
+    preview: conversation.preview,
+    collabAgentId: conversation.collabAgentId ?? null,
+    collabChannelId: conversation.collabChannelId ?? null,
+    createdByMe: conversation.createdByMe ?? null
   };
 }
+function foldConversationIndex(conversations, indexByThread) {
+  return conversations.map((conversation) => {
+    const entry = indexByThread.get(conversation.threadId);
+    if (!entry) return conversation;
+    const merged = summaryFromConversationIndexEntry(entry, conversation);
+    return normalizeThreadTitle(merged.title) === void 0 ? { ...merged, title: conversation.title } : merged;
+  });
+}
+const AthenaSessionsLiveContext = createContext(null);
 const THREAD_LIST_PAGE_SIZE = 50;
 function StatewireThreadListState({
   backendUrl,
@@ -54,6 +79,7 @@ function StatewireThreadListState({
   token,
   getToken,
   appId,
+  additionalListAppIds,
   initialThreadId,
   includePullRequests,
   snapshotCache,
@@ -88,20 +114,25 @@ function StatewireThreadListState({
     [backendUrl, includePullRequests, getAuth]
   );
   const trimmedSearch = search.trim();
+  const additionalListAppIdsKey = JSON.stringify(additionalListAppIds ?? []);
+  const listedAppIds = useMemo(
+    () => JSON.parse(additionalListAppIdsKey),
+    [additionalListAppIdsKey]
+  );
   const filter = useMemo(
     () => ({
       ...appId ? { appId } : {},
+      ...listedAppIds.length > 0 ? { appIds: listedAppIds } : {},
       ...trimmedSearch ? { search: trimmedSearch } : {}
     }),
-    [appId, trimmedSearch]
+    [appId, listedAppIds, trimmedSearch]
   );
+  const listScopeKey = `${backendUrl}::${principal}::${hasAuth ? "auth" : "anon"}::${includePullRequests ? "prs" : "no-prs"}`;
   const list = useConversationList({
     fetchPage,
     filter,
     pageSize: THREAD_LIST_PAGE_SIZE,
-    // Pull-request opt-in changes what a cached row holds, so it is part of
-    // the cache identity.
-    scopeKey: `${backendUrl}::${principal}::${hasAuth ? "auth" : "anon"}::${includePullRequests ? "prs" : "no-prs"}`,
+    scopeKey: listScopeKey,
     enabled: hasAuth
   });
   const indexHeaders = useCallback(
@@ -148,21 +179,23 @@ function StatewireThreadListState({
     return entries;
   }, [index.entries]);
   const mergedConversations = useMemo(
-    () => list.conversations.map((conversation) => {
-      const entry = indexByThread.get(conversation.threadId);
-      if (!entry) return conversation;
-      const merged = summaryFromConversationIndexEntry(entry, conversation);
-      return normalizeThreadTitle(merged.title) === void 0 ? { ...merged, title: conversation.title } : merged;
-    }),
+    () => foldConversationIndex(list.conversations, indexByThread),
     [list.conversations, indexByThread]
   );
-  const listPatchConversation = list.patchConversation;
+  const queryClient = useQueryClient();
+  const patchEveryList = useCallback(
+    (threadId, patch) => patchConversationListCaches(queryClient, {
+      match: (item) => item.threadId === threadId,
+      patch
+    }),
+    [queryClient]
+  );
   const favorite = useThreadFavorite({
     backendUrl,
     principalId: principal,
     getAuth,
     rows: mergedConversations,
-    onServerTruth: ({ threadId, isFavorited }) => listPatchConversation(threadId, { isFavorited })
+    onServerTruth: ({ threadId, isFavorited }) => patchEveryList(threadId, { isFavorited })
   });
   const favoriteOverrides = favorite.overrides;
   const rename = useThreadRename({
@@ -170,16 +203,24 @@ function StatewireThreadListState({
     principalId: principal,
     getAuth,
     rows: mergedConversations,
-    onServerTruth: ({ threadId, title }) => listPatchConversation(threadId, { title })
+    onServerTruth: ({ threadId, title }) => patchEveryList(threadId, { title })
   });
   const titleOverrides = rename.overrides;
-  const listRemoveConversation = list.removeConversation;
+  const readState = useThreadReadState({
+    backendUrl,
+    principalId: principal,
+    getAuth,
+    rows: mergedConversations,
+    onServerTruth: ({ threadId, isUnread }) => patchEveryList(threadId, { isUnread })
+  });
+  const readOverrides = readState.overrides;
+  const readCoveredUpdatedAt = readState.coveredUpdatedAt;
   const archive = useThreadArchive({
     backendUrl,
     principalId: principal,
     getAuth,
     onArchived: (threadId) => {
-      listRemoveConversation(threadId);
+      removeConversationFromListCaches(queryClient, { threadId });
       setActive(
         (current) => current.id === threadId ? { id: mintThreadId(), isNew: true } : current
       );
@@ -194,12 +235,17 @@ function StatewireThreadListState({
     );
     if (forgotten.length > 0) archiveRelease(forgotten);
   }, [hiddenThreadIds, mergedConversations, indexByThread, archiveRelease]);
+  const applyOverrides = useCallback(
+    (rows) => withReadStateOverrides(
+      withTitleOverrides(withFavoriteOverrides(rows, favoriteOverrides), titleOverrides),
+      readOverrides,
+      readCoveredUpdatedAt
+    ).filter((conversation) => !hiddenThreadIds.has(conversation.threadId)),
+    [favoriteOverrides, titleOverrides, readOverrides, readCoveredUpdatedAt, hiddenThreadIds]
+  );
   const data = useMemo(
-    () => withTitleOverrides(
-      withFavoriteOverrides(mergedConversations, favoriteOverrides),
-      titleOverrides
-    ).filter((conversation) => !hiddenThreadIds.has(conversation.threadId)).map(threadSummaryFromConversation),
-    [mergedConversations, favoriteOverrides, titleOverrides, hiddenThreadIds]
+    () => applyOverrides(mergedConversations).map(threadSummaryFromConversation),
+    [applyOverrides, mergedConversations]
   );
   const isLoading = list.isLoading;
   const lastActiveConversationRef = useRef(null);
@@ -215,12 +261,18 @@ function StatewireThreadListState({
   if (activeConversation !== null) lastActiveConversationRef.current = activeConversation;
   const activeThread = useMemo(
     () => activeConversation ? threadSummaryFromConversation(
-      withTitleOverride(
-        withFavoriteOverride(activeConversation, favoriteOverrides),
-        titleOverrides
-      )
+      withReadStateOverrides(
+        [
+          withTitleOverride(
+            withFavoriteOverride(activeConversation, favoriteOverrides),
+            titleOverrides
+          )
+        ],
+        readOverrides,
+        readCoveredUpdatedAt
+      )[0] ?? activeConversation
     ) : null,
-    [activeConversation, favoriteOverrides, titleOverrides]
+    [activeConversation, favoriteOverrides, titleOverrides, readOverrides, readCoveredUpdatedAt]
   );
   const listRefresh = list.refresh;
   const refresh = useCallback(() => {
@@ -233,16 +285,16 @@ function StatewireThreadListState({
   const refreshedForRef = useRef(/* @__PURE__ */ new Set());
   useEffect(() => {
     if (index.entries === null) return;
-    const listed = new Set(list.conversations.map((conversation) => conversation.threadId));
-    let pending = false;
-    for (const entry of index.entries) {
-      if (appId && entry.app_id !== appId) continue;
-      if (listed.has(entry.thread_id) || refreshedForRef.current.has(entry.thread_id)) continue;
-      refreshedForRef.current.add(entry.thread_id);
-      pending = true;
-    }
-    if (pending) void listRefresh();
-  }, [index.entries, list.conversations, appId, listRefresh]);
+    const unlisted = indexedThreadsToRefreshFor({
+      entries: index.entries,
+      listedThreadIds: new Set(list.conversations.map((conversation) => conversation.threadId)),
+      refreshedThreadIds: refreshedForRef.current,
+      appId,
+      additionalAppIds: listedAppIds
+    });
+    for (const threadId of unlisted) refreshedForRef.current.add(threadId);
+    if (unlisted.length > 0) void listRefresh();
+  }, [index.entries, list.conversations, appId, listedAppIds, listRefresh]);
   const selectThread = useCallback((threadId) => {
     if (!threadId) return;
     setActive(
@@ -312,6 +364,8 @@ function StatewireThreadListState({
       archivePendingThreadIds: archive.pendingThreadIds,
       archivePending: archive.isPending,
       archiveAvailable: archive.isAvailable,
+      setReadState: readState.setReadState,
+      readStatePendingThreadIds: readState.pendingThreadIds,
       titleSource
     }),
     [
@@ -341,10 +395,44 @@ function StatewireThreadListState({
       archive.pendingThreadIds,
       archive.isPending,
       archive.isAvailable,
+      readState.setReadState,
+      readState.pendingThreadIds,
       titleSource
     ]
   );
-  return /* @__PURE__ */ jsx(AthenaStatewireThreadListContext.Provider, { value, children });
+  const live = useMemo(
+    () => ({
+      backendUrl,
+      getAuth,
+      principal,
+      hasAuth,
+      includePullRequests,
+      scopeKey: listScopeKey,
+      credentialGeneration,
+      baseFilter: {
+        ...appId ? { appId } : {},
+        ...listedAppIds.length > 0 ? { appIds: listedAppIds } : {}
+      },
+      indexByThread,
+      indexEntries: index.entries,
+      applyOverrides
+    }),
+    [
+      backendUrl,
+      getAuth,
+      principal,
+      hasAuth,
+      includePullRequests,
+      listScopeKey,
+      credentialGeneration,
+      appId,
+      listedAppIds,
+      indexByThread,
+      index.entries,
+      applyOverrides
+    ]
+  );
+  return /* @__PURE__ */ jsx(AthenaStatewireThreadListContext.Provider, { value, children: /* @__PURE__ */ jsx(AthenaSessionsLiveContext.Provider, { value: live, children }) });
 }
 function AthenaStatewireThreadListProvider({
   backendUrl,
@@ -353,6 +441,7 @@ function AthenaStatewireThreadListProvider({
   token,
   getToken,
   appId,
+  additionalListAppIds,
   initialThreadId,
   includePullRequests = true,
   snapshotCache,
@@ -368,6 +457,7 @@ function AthenaStatewireThreadListProvider({
       token,
       getToken,
       appId,
+      additionalListAppIds,
       initialThreadId,
       includePullRequests,
       snapshotCache,
@@ -421,10 +511,13 @@ function StatewireThreadTitlePoller() {
   return null;
 }
 export {
+  AthenaSessionsLiveContext,
   AthenaStatewireThreadListContext,
   AthenaStatewireThreadListProvider,
   StatewireThreadTitlePoller,
   TITLE_POLL_DELAY_MS,
+  foldConversationIndex,
+  indexedThreadsToRefreshFor,
   threadSummaryFromConversation,
   useAthenaStatewireThreadList,
   useRefreshThreadList