@athenaintel/react 0.28.0 → 0.30.0

package/dist/threads/use-athena-sessions.js

@@ -0,0 +1,198 @@
+import { useQuery } from "@tanstack/react-query";
+import { useContext, useMemo, useRef, useEffect } from "react";
+import { useAthenaQueryClient } from "../lib/use-athena-rest-query.js";
+import { withCredentialRenewal } from "../runtime/credential-renewal.js";
+import { listThreads } from "./api.js";
+import { createRestConversationListFetcher } from "./conversation-list-fetcher.js";
+import { supportedFiltersFromResponse, sessionsQueryKey, planSessionsQuery, sessionsQueryFromKey, unavailableSessionsQueryFields, matchesSessionsQuery, sortSessions } from "./sessions-query.js";
+import { AthenaSessionsLiveContext, foldConversationIndex, threadSummaryFromConversation, indexedThreadsToRefreshFor } from "./statewire-thread-list.js";
+import { useConversationList } from "../agent-runtime/src/use-conversation-list.js";
+const DEFAULT_PAGE_SIZE = 50;
+const THREAD_LIST_CAPABILITIES_QUERY_KEY = [
+  "athena-sdk",
+  "thread-list-capabilities"
+];
+const EMPTY_ROWS = [];
+const NOOP = () => void 0;
+const NOOP_ASYNC = async () => void 0;
+function useAthenaSessions({
+  query,
+  pageSize = DEFAULT_PAGE_SIZE,
+  enabled = true
+}) {
+  const live = useContext(AthenaSessionsLiveContext);
+  const isAvailable = live !== null;
+  const backendUrl = (live == null ? void 0 : live.backendUrl) ?? "";
+  const principal = (live == null ? void 0 : live.principal) ?? "";
+  const hasAuth = (live == null ? void 0 : live.hasAuth) ?? false;
+  const includePullRequests = (live == null ? void 0 : live.includePullRequests) ?? false;
+  const getAuth = live == null ? void 0 : live.getAuth;
+  const active = isAvailable && enabled && hasAuth;
+  const identityScope = `${(live == null ? void 0 : live.scopeKey) ?? "unavailable"}::credential-${(live == null ? void 0 : live.credentialGeneration) ?? 0}`;
+  const queryClient = useAthenaQueryClient();
+  const capabilities = useQuery(
+    {
+      queryKey: [
+        ...THREAD_LIST_CAPABILITIES_QUERY_KEY,
+        backendUrl,
+        principal,
+        (live == null ? void 0 : live.credentialGeneration) ?? 0
+      ],
+      queryFn: async ({ signal }) => {
+        if (!getAuth) return null;
+        const response = await withCredentialRenewal(
+          getAuth,
+          (auth) => listThreads(backendUrl, auth, { limit: 1, signal })
+        );
+        return supportedFiltersFromResponse(response.supported_filters);
+      },
+      enabled: active,
+      staleTime: Number.POSITIVE_INFINITY,
+      retry: 1
+    },
+    queryClient
+  );
+  const capabilitiesSettled = capabilities.isSuccess || capabilities.isError;
+  const supportedFilters = capabilities.data ?? null;
+  const queryKey = sessionsQueryKey(query);
+  const plan = useMemo(
+    () => planSessionsQuery(sessionsQueryFromKey(queryKey), {
+      supportedFilters,
+      includePullRequests
+    }),
+    [queryKey, supportedFilters, includePullRequests]
+  );
+  const planRef = useRef(plan);
+  planRef.current = plan;
+  const unsupportedFields = useMemo(
+    () => capabilitiesSettled ? unavailableSessionsQueryFields({ supportedFilters, includePullRequests }) : [],
+    [capabilitiesSettled, supportedFilters, includePullRequests]
+  );
+  const fetchPage = useMemo(
+    () => getAuth ? createRestConversationListFetcher({
+      backendUrl,
+      getAuth,
+      includePullRequests,
+      extraFilters: plan.body,
+      keepRow: (row) => matchesSessionsQuery(row, planRef.current.local)
+    }) : async () => ({ items: [], hasMore: false, totalCount: null }),
+    [backendUrl, getAuth, includePullRequests, plan.body]
+  );
+  const baseFilter = (live == null ? void 0 : live.baseFilter) ?? {};
+  const capabilityKey = supportedFilters ? [...supportedFilters].sort().join(",") : "legacy";
+  const list = useConversationList({
+    fetchPage,
+    filter: baseFilter,
+    pageSize,
+    // The query's server filters are not part of the shared filter contract,
+    // so they — and what this backend applies of them — key the cache here.
+    scopeKey: `${identityScope}::sessions::${queryKey}::${capabilityKey}`,
+    enabled: active && capabilitiesSettled,
+    queryClient
+  });
+  const lastResolvedRef = useRef({
+    scope: "",
+    conversations: []
+  });
+  if (list.hasResolvedFirstPage) {
+    lastResolvedRef.current = { scope: identityScope, conversations: list.conversations };
+  }
+  const standIn = !list.hasResolvedFirstPage && lastResolvedRef.current.scope === identityScope ? lastResolvedRef.current.conversations : null;
+  const source = standIn ?? list.conversations;
+  const isPlaceholderData = standIn !== null && standIn.length > 0;
+  const indexByThread = live == null ? void 0 : live.indexByThread;
+  const applyOverrides = live == null ? void 0 : live.applyOverrides;
+  const rows = useMemo(() => {
+    if (!indexByThread || !applyOverrides) return EMPTY_ROWS;
+    const folded = applyOverrides(
+      foldConversationIndex(source, indexByThread)
+    ).filter((row) => matchesSessionsQuery(row, plan.local));
+    return sortSessions(folded, plan.local).map(threadSummaryFromConversation);
+  }, [source, indexByThread, applyOverrides, plan.local]);
+  const refreshedForRef = useRef(/* @__PURE__ */ new Set());
+  const indexEntries = (live == null ? void 0 : live.indexEntries) ?? null;
+  const listRefresh = list.refresh;
+  const baseAppId = baseFilter.appId;
+  const baseAppIds = baseFilter.appIds;
+  useEffect(() => {
+    if (!active || indexEntries === null || !list.hasResolvedFirstPage) return;
+    const unlisted = indexEntryVersionsToRefresh({
+      entries: indexEntries,
+      listedThreadIds: new Set(list.conversations.map((conversation) => conversation.threadId)),
+      refreshedVersions: refreshedForRef.current,
+      appId: baseAppId,
+      additionalAppIds: baseAppIds ?? [],
+      query: plan.local
+    });
+    for (const version of unlisted) refreshedForRef.current.add(version);
+    if (unlisted.length > 0) void listRefresh();
+  }, [
+    active,
+    indexEntries,
+    list.hasResolvedFirstPage,
+    list.conversations,
+    baseAppId,
+    baseAppIds,
+    listRefresh,
+    plan.local
+  ]);
+  const listFetchNextPage = list.fetchNextPage;
+  return {
+    rows: isAvailable ? rows : EMPTY_ROWS,
+    isAvailable,
+    isLoading: active && (!capabilitiesSettled || list.isLoading),
+    isFetching: list.isFetching || capabilities.isFetching,
+    hasResolvedFirstPage: list.hasResolvedFirstPage,
+    isPlaceholderData,
+    hasNextPage: list.hasNextPage,
+    isFetchingNextPage: list.isFetchingNextPage,
+    fetchNextPage: isAvailable ? () => void listFetchNextPage() : NOOP,
+    refresh: isAvailable ? async () => void await listRefresh() : NOOP_ASYNC,
+    isFetchNextPageError: list.isFetchNextPageError,
+    supportedFilters,
+    degradedFields: plan.degraded,
+    unavailableFields: plan.unavailable,
+    unsupportedFields
+  };
+}
+function indexEntryVersionsToRefresh({
+  entries,
+  listedThreadIds,
+  refreshedVersions,
+  appId,
+  additionalAppIds,
+  query
+}) {
+  const versionOf = (entry) => `${entry.thread_id}@${entry.updated_at}`;
+  const byVersion = new Map(entries.map((entry) => [versionOf(entry), entry]));
+  return indexedThreadsToRefreshFor({
+    entries: entries.map((entry) => ({ thread_id: versionOf(entry), app_id: entry.app_id })),
+    listedThreadIds: new Set(
+      entries.filter((entry) => listedThreadIds.has(entry.thread_id)).map(versionOf)
+    ),
+    refreshedThreadIds: refreshedVersions,
+    appId,
+    additionalAppIds
+  }).filter((version) => {
+    const entry = byVersion.get(version);
+    return entry === void 0 || entryCouldMatch(entry, query);
+  });
+}
+function entryCouldMatch(entry, query) {
+  if (query.unreadOnly && entry.is_unread === false) return false;
+  if (query.favoritesOnly && entry.is_favorited === false) return false;
+  if (query.runStatuses && typeof entry.run_status === "string" && !query.runStatuses.includes(entry.run_status)) {
+    return false;
+  }
+  if (query.sessionStatuses && typeof entry.session_status === "string" && !query.sessionStatuses.includes(entry.session_status)) {
+    return false;
+  }
+  return true;
+}
+export {
+  THREAD_LIST_CAPABILITIES_QUERY_KEY,
+  entryCouldMatch,
+  indexEntryVersionsToRefresh,
+  useAthenaSessions
+};
+//# sourceMappingURL=use-athena-sessions.js.map

package/dist/threads/use-athena-sessions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-athena-sessions.js","sources":["../../src/threads/use-athena-sessions.ts"],"sourcesContent":["/**\n * `useAthenaSessions(query)` — one filtered, sorted, live session list under\n * `<AthenaProvider enableThreadList>`: the data layer of `SessionsPage` and\n * `Inbox`, for hosts drawing their own.\n *\n * - **Server-side.** The query travels to `POST /api/conversations/threads/list`\n *   as filters of the server's one page statement (`planSessionsQuery`), over\n *   the shared two-tier pager (`useConversationList`: a live first page and\n *   frozen history pages) in the thread-list provider's query client.\n * - **Live.** Rows fold the same conversation-index pushes the sidebar folds\n *   (titles, lifecycle, attention flip in place), carry the provider's\n *   in-flight writes (pin, rename, read state, archive), and a thread the\n *   index learns about that the list does not show yet refreshes the list\n *   once.\n * - **Degraded, not wrong.** A server that cannot apply part of the query is\n *   detected from its `supported_filters` echo (one `limit: 1` probe per\n *   identity). Fields the loaded rows can be tested on are applied to them\n *   (`degradedFields`: exact per page, a page can come back short); fields\n *   they cannot are reported in `unavailableFields` and not applied, so a\n *   control for them can be disabled rather than lie.\n */\nimport {\n  type ConversationListFilter,\n  type ConversationSummary,\n  useConversationList,\n} from '@athenaintel/agent-runtime';\nimport { useQuery } from '@tanstack/react-query';\nimport { useContext, useEffect, useMemo, useRef } from 'react';\nimport { useAthenaQueryClient } from '../lib/use-athena-rest-query';\nimport { withCredentialRenewal } from '../runtime/credential-renewal';\nimport { listThreads } from './api';\nimport { createRestConversationListFetcher } from './conversation-list-fetcher';\nimport {\n  type AthenaSessionsQuery,\n  type AthenaSessionsQueryField,\n  matchesSessionsQuery,\n  planSessionsQuery,\n  sessionsQueryFromKey,\n  sessionsQueryKey,\n  sortSessions,\n  supportedFiltersFromResponse,\n  unavailableSessionsQueryFields,\n} from './sessions-query';\nimport {\n  AthenaSessionsLiveContext,\n  type AthenaStatewireThreadSummary,\n  foldConversationIndex,\n  indexedThreadsToRefreshFor,\n  threadSummaryFromConversation,\n} from './statewire-thread-list';\n\nexport interface UseAthenaSessionsOptions {\n  /** What to list. A new object with the same content does not refetch. */\n  query: AthenaSessionsQuery;\n  /** Rows per page (default 50). */\n  pageSize?: number;\n  /** `false` holds the list idle. Default `true`. */\n  enabled?: boolean;\n}\n\nexport interface AthenaSessionsList {\n  /** The rows, in the query's order, with live pushes and in-flight writes applied. */\n  rows: AthenaStatewireThreadSummary[];\n  /** `false` outside `enableThreadList` mode: nothing is fetched and `rows` stays empty. */\n  isAvailable: boolean;\n  /** True until the first page has answered (or while no credential has resolved). */\n  isLoading: boolean;\n  isFetching: boolean;\n  hasResolvedFirstPage: boolean;\n  /**\n   * True while the rows are the previous query's (checked against this\n   * query's local part) because this query's first page is still in flight.\n   */\n  isPlaceholderData: boolean;\n  hasNextPage: boolean;\n  isFetchingNextPage: boolean;\n  fetchNextPage: () => void;\n  /** Refetch the first page; resolves once it has answered. */\n  refresh: () => Promise<void>;\n  /** True while the last \"load more\" request failed. */\n  isFetchNextPageError: boolean;\n  /**\n   * The server fields this backend applies (`supported_filters`), `null`\n   * while unknown or on a backend that predates the list.\n   */\n  supportedFilters: ReadonlySet<string> | null;\n  /** Fields applied to the loaded rows because the backend cannot. */\n  degradedFields: AthenaSessionsQueryField[];\n  /** Fields of this query that cannot be applied on this backend at all (and are not). */\n  unavailableFields: AthenaSessionsQueryField[];\n  /**\n   * Every field this backend cannot apply anywhere, selected or not — what a\n   * filter UI disables. Empty until the capabilities probe has answered.\n   */\n  unsupportedFields: AthenaSessionsQueryField[];\n}\n\nconst DEFAULT_PAGE_SIZE = 50;\n\n/** The capabilities probe's key prefix. */\nexport const THREAD_LIST_CAPABILITIES_QUERY_KEY = [\n  'athena-sdk',\n  'thread-list-capabilities',\n] as const;\n\nconst EMPTY_ROWS: AthenaStatewireThreadSummary[] = [];\nconst NOOP = () => undefined;\nconst NOOP_ASYNC = async () => undefined;\n\nexport function useAthenaSessions({\n  query,\n  pageSize = DEFAULT_PAGE_SIZE,\n  enabled = true,\n}: UseAthenaSessionsOptions): AthenaSessionsList {\n  const live = useContext(AthenaSessionsLiveContext);\n  const isAvailable = live !== null;\n  const backendUrl = live?.backendUrl ?? '';\n  const principal = live?.principal ?? '';\n  const hasAuth = live?.hasAuth ?? false;\n  const includePullRequests = live?.includePullRequests ?? false;\n  const getAuth = live?.getAuth;\n  const active = isAvailable && enabled && hasAuth;\n  // Every cache below is keyed by WHO reads (principal) and WITH WHAT (the\n  // credential generation): a scoped credential for another workspace under\n  // the same principal must never read this one's cached rows.\n  const identityScope = `${live?.scopeKey ?? 'unavailable'}::credential-${\n    live?.credentialGeneration ?? 0\n  }`;\n\n  // Outside thread-list mode there may be no `QueryClientProvider`; every\n  // query below is disabled there, on a client of this hook's own.\n  const queryClient = useAthenaQueryClient();\n\n  // Which filters this backend applies: one tiny page per identity. The\n  // answer is a property of the deployed agora, so it never goes stale.\n  const capabilities = useQuery(\n    {\n      queryKey: [\n        ...THREAD_LIST_CAPABILITIES_QUERY_KEY,\n        backendUrl,\n        principal,\n        live?.credentialGeneration ?? 0,\n      ],\n      queryFn: async ({ signal }) => {\n        if (!getAuth) return null;\n        const response = await withCredentialRenewal(getAuth, (auth) =>\n          listThreads(backendUrl, auth, { limit: 1, signal }),\n        );\n        return supportedFiltersFromResponse(response.supported_filters);\n      },\n      enabled: active,\n      staleTime: Number.POSITIVE_INFINITY,\n      retry: 1,\n    },\n    queryClient,\n  );\n  // A failed probe is treated as an older backend: the query degrades\n  // instead of the list staying empty.\n  const capabilitiesSettled = capabilities.isSuccess || capabilities.isError;\n  const supportedFilters = capabilities.data ?? null;\n\n  // `query` may be a fresh object every render; its normalized key is what\n  // identifies it, so the plan is built from the key and recomputed only\n  // when the content changes.\n  const queryKey = sessionsQueryKey(query);\n  const plan = useMemo(\n    () =>\n      planSessionsQuery(sessionsQueryFromKey(queryKey), {\n        supportedFilters,\n        includePullRequests,\n      }),\n    [queryKey, supportedFilters, includePullRequests],\n  );\n  const planRef = useRef(plan);\n  planRef.current = plan;\n  const unsupportedFields = useMemo(\n    () =>\n      capabilitiesSettled\n        ? unavailableSessionsQueryFields({ supportedFilters, includePullRequests })\n        : [],\n    [capabilitiesSettled, supportedFilters, includePullRequests],\n  );\n\n  const fetchPage = useMemo(\n    () =>\n      getAuth\n        ? createRestConversationListFetcher({\n            backendUrl,\n            getAuth,\n            includePullRequests,\n            extraFilters: plan.body,\n            keepRow: (row) => matchesSessionsQuery(row, planRef.current.local),\n          })\n        : async () => ({ items: [], hasMore: false, totalCount: null }),\n    [backendUrl, getAuth, includePullRequests, plan.body],\n  );\n  const baseFilter: ConversationListFilter = live?.baseFilter ?? {};\n  const capabilityKey = supportedFilters ? [...supportedFilters].sort().join(',') : 'legacy';\n  const list = useConversationList({\n    fetchPage,\n    filter: baseFilter,\n    pageSize,\n    // The query's server filters are not part of the shared filter contract,\n    // so they — and what this backend applies of them — key the cache here.\n    scopeKey: `${identityScope}::sessions::${queryKey}::${capabilityKey}`,\n    enabled: active && capabilitiesSettled,\n    queryClient,\n  });\n\n  // While a changed query's first page is in flight, the previous query's\n  // rows stand in, checked against the new query's local part — the list\n  // narrows at once instead of blanking to skeletons. Only rows read as the\n  // same identity and credential ever stand in.\n  const lastResolvedRef = useRef<{ scope: string; conversations: ConversationSummary[] }>({\n    scope: '',\n    conversations: [],\n  });\n  if (list.hasResolvedFirstPage) {\n    lastResolvedRef.current = { scope: identityScope, conversations: list.conversations };\n  }\n  const standIn =\n    !list.hasResolvedFirstPage && lastResolvedRef.current.scope === identityScope\n      ? lastResolvedRef.current.conversations\n      : null;\n  const source = standIn ?? list.conversations;\n  const isPlaceholderData = standIn !== null && standIn.length > 0;\n\n  const indexByThread = live?.indexByThread;\n  const applyOverrides = live?.applyOverrides;\n  const rows = useMemo(() => {\n    if (!indexByThread || !applyOverrides) return EMPTY_ROWS;\n    const folded: ConversationSummary[] = applyOverrides(\n      foldConversationIndex(source, indexByThread),\n    ).filter((row) => matchesSessionsQuery(row, plan.local));\n    return sortSessions(folded, plan.local).map(threadSummaryFromConversation);\n  }, [source, indexByThread, applyOverrides, plan.local]);\n\n  // A thread the index knows that this list does not show yet refreshes the\n  // list — it may be new, or may have just come to match. Once per VERSION of\n  // the entry (its id and `updated_at`): an unchanged entry the server keeps\n  // leaving out never refreshes twice, and a later change to it (a PR opened,\n  // a run now needing input) gets its own refresh.\n  const refreshedForRef = useRef<Set<string>>(new Set());\n  const indexEntries = live?.indexEntries ?? null;\n  const listRefresh = list.refresh;\n  const baseAppId = baseFilter.appId;\n  const baseAppIds = baseFilter.appIds;\n  useEffect(() => {\n    if (!active || indexEntries === null || !list.hasResolvedFirstPage) return;\n    const unlisted = indexEntryVersionsToRefresh({\n      entries: indexEntries,\n      listedThreadIds: new Set(list.conversations.map((conversation) => conversation.threadId)),\n      refreshedVersions: refreshedForRef.current,\n      appId: baseAppId,\n      additionalAppIds: baseAppIds ?? [],\n      query: plan.local,\n    });\n    for (const version of unlisted) refreshedForRef.current.add(version);\n    if (unlisted.length > 0) void listRefresh();\n  }, [\n    active,\n    indexEntries,\n    list.hasResolvedFirstPage,\n    list.conversations,\n    baseAppId,\n    baseAppIds,\n    listRefresh,\n    plan.local,\n  ]);\n\n  const listFetchNextPage = list.fetchNextPage;\n  return {\n    rows: isAvailable ? rows : EMPTY_ROWS,\n    isAvailable,\n    isLoading: active && (!capabilitiesSettled || list.isLoading),\n    isFetching: list.isFetching || capabilities.isFetching,\n    hasResolvedFirstPage: list.hasResolvedFirstPage,\n    isPlaceholderData,\n    hasNextPage: list.hasNextPage,\n    isFetchingNextPage: list.isFetchingNextPage,\n    fetchNextPage: isAvailable ? () => void listFetchNextPage() : NOOP,\n    refresh: isAvailable ? async () => void (await listRefresh()) : NOOP_ASYNC,\n    isFetchNextPageError: list.isFetchNextPageError,\n    supportedFilters,\n    degradedFields: plan.degraded,\n    unavailableFields: plan.unavailable,\n    unsupportedFields,\n  };\n}\n\ntype IndexEntryLike = Parameters<typeof entryCouldMatch>[0] & {\n  thread_id: string;\n  updated_at: string;\n  app_id: string | null;\n};\n\n/**\n * The index entries that warrant one refresh of a filtered list, as\n * `<thread_id>@<updated_at>` versions: entries the list does not show, of\n * the apps it lists, that the query could match on what the entry carries,\n * and whose version has not prompted a refresh before. An unchanged entry the\n * server keeps leaving out refreshes once; any later change to it refreshes\n * again. Exported for tests.\n */\nexport function indexEntryVersionsToRefresh({\n  entries,\n  listedThreadIds,\n  refreshedVersions,\n  appId,\n  additionalAppIds,\n  query,\n}: {\n  entries: readonly IndexEntryLike[];\n  listedThreadIds: ReadonlySet<string>;\n  refreshedVersions: ReadonlySet<string>;\n  appId: string | undefined;\n  additionalAppIds: readonly string[];\n  query: AthenaSessionsQuery;\n}): string[] {\n  const versionOf = (entry: IndexEntryLike) => `${entry.thread_id}@${entry.updated_at}`;\n  const byVersion = new Map(entries.map((entry) => [versionOf(entry), entry]));\n  return indexedThreadsToRefreshFor({\n    entries: entries.map((entry) => ({ thread_id: versionOf(entry), app_id: entry.app_id })),\n    listedThreadIds: new Set(\n      entries.filter((entry) => listedThreadIds.has(entry.thread_id)).map(versionOf),\n    ),\n    refreshedThreadIds: refreshedVersions,\n    appId,\n    additionalAppIds,\n  }).filter((version) => {\n    const entry = byVersion.get(version);\n    return entry === undefined || entryCouldMatch(entry, query);\n  });\n}\n\n/**\n * Whether a pushed index entry could belong to a list with this local query:\n * the fields the entry carries are checked, the rest pass.\n */\nexport function entryCouldMatch(\n  entry: {\n    is_unread?: boolean | null;\n    is_favorited?: boolean | null;\n    run_status?: string | null;\n    session_status?: string | null;\n  },\n  query: AthenaSessionsQuery,\n): boolean {\n  if (query.unreadOnly && entry.is_unread === false) return false;\n  if (query.favoritesOnly && entry.is_favorited === false) return false;\n  if (\n    query.runStatuses &&\n    typeof entry.run_status === 'string' &&\n    !(query.runStatuses as readonly string[]).includes(entry.run_status)\n  ) {\n    return false;\n  }\n  if (\n    query.sessionStatuses &&\n    typeof entry.session_status === 'string' &&\n    !(query.sessionStatuses as readonly string[]).includes(entry.session_status)\n  ) {\n    return false;\n  }\n  return true;\n}\n"],"names":[],"mappings":"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"}

package/dist/threads/use-rest-conversation-history.cjs

@@ -6,7 +6,7 @@ const credentialRenewal = require("../runtime/credential-renewal.cjs");
 const api = require("./api.cjs");
 const conversationListFetcher = require("./conversation-list-fetcher.cjs");
 const useThreadFavorite = require("./use-thread-favorite.cjs");
-const useConversationList = require("../packages/agent-runtime/src/use-conversation-list.cjs");
+const useConversationList = require("../agent-runtime/src/use-conversation-list.cjs");
 function useRestConversationHistory({
   backendUrl,
   principalId,

package/dist/threads/use-rest-conversation-history.js

@@ -4,7 +4,7 @@ import { withCredentialRenewal } from "../runtime/credential-renewal.js";
 import { setThreadReadState, archiveThread } from "./api.js";
 import { createRestConversationListFetcher } from "./conversation-list-fetcher.js";
 import { useThreadFavorite, withFavoriteOverrides } from "./use-thread-favorite.js";
-import { useConversationList } from "../packages/agent-runtime/src/use-conversation-list.js";
+import { useConversationList } from "../agent-runtime/src/use-conversation-list.js";
 function useRestConversationHistory({
   backendUrl,
   principalId,

package/dist/threads/use-statewire-conversation-history.cjs

@@ -6,7 +6,7 @@ const credentialRenewal = require("../runtime/credential-renewal.cjs");
 const api = require("./api.cjs");
 const useRestConversationHistory = require("./use-rest-conversation-history.cjs");
 const useThreadFavorite = require("./use-thread-favorite.cjs");
-const conversationIndex = require("../packages/agent-runtime/src/conversation-index.cjs");
+const conversationIndex = require("../agent-runtime/src/conversation-index.cjs");
 function conversationSummaryFromIndexEntry(entry) {
   return {
     threadId: entry.thread_id,

package/dist/threads/use-statewire-conversation-history.d.ts

@@ -48,6 +48,8 @@ export declare function useStatewireConversationHistory({ backendUrl, conversati
         assetId: string | null;
         appId: string | null;
         computerAssetId?: string | null;
+        collabAgentId?: string | null;
+        collabChannelId?: string | null;
         parentSessionId?: string | null;
         subSessionCount?: number;
         triggerType: string | null;
@@ -59,6 +61,7 @@ export declare function useStatewireConversationHistory({ backendUrl, conversati
         nextAction?: string | null;
         attentionSource?: import("@athenaintel/agent-runtime").ConversationAttentionSource | null;
         isFavorited?: boolean;
+        createdByMe?: boolean;
         lastWake?: import("@athenaintel/agent-runtime").ConversationWake | null;
         pullRequests?: import("@athenaintel/agent-runtime").ConversationPullRequest[] | null;
         isUnread: boolean;

package/dist/threads/use-statewire-conversation-history.js

@@ -4,7 +4,7 @@ import { withCredentialRenewal } from "../runtime/credential-renewal.js";
 import { setThreadReadState, archiveThread } from "./api.js";
 import { useRestConversationHistory } from "./use-rest-conversation-history.js";
 import { useThreadFavorite, withFavoriteOverrides } from "./use-thread-favorite.js";
-import { useConversationIndex } from "../packages/agent-runtime/src/conversation-index.js";
+import { useConversationIndex } from "../agent-runtime/src/conversation-index.js";
 function conversationSummaryFromIndexEntry(entry) {
   return {
     threadId: entry.thread_id,

package/dist/threads/use-thread-read-state.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const api = require("./api.cjs");
+const useThreadFieldOverride = require("./use-thread-field-override.cjs");
+const READ_STATE_UNAVAILABLE_WARNING = "[AthenaSDK] This backend has no POST /api/conversations/threads/read-state route; sessions cannot be marked read from here.";
+const isReadStateUnavailableError = () => false;
+const readUnread = (row) => row.isUnread;
+function useThreadReadState({
+  backendUrl,
+  principalId,
+  getAuth,
+  rows,
+  onServerTruth
+}) {
+  const field = useThreadFieldOverride.useThreadFieldOverride({
+    field: "read-state",
+    backendUrl,
+    principalId,
+    getAuth,
+    rows,
+    readRow: readUnread,
+    write: async (auth, { threadId, value }) => {
+      const result = await api.setThreadReadState(backendUrl, auth, { threadId, isUnread: value });
+      return { threadId: result.thread_id, value: result.is_unread };
+    },
+    isUnavailableError: isReadStateUnavailableError,
+    unavailableWarning: READ_STATE_UNAVAILABLE_WARNING,
+    onServerTruth: onServerTruth ? ({ threadId, value }) => onServerTruth({ threadId, isUnread: value }) : void 0
+  });
+  const set = field.set;
+  const rowsRef = react.useRef(rows);
+  rowsRef.current = rows;
+  const [coveredUpdatedAt, setCoveredUpdatedAt] = react.useState({});
+  const setReadState = react.useCallback(
+    ({ threadId, isUnread, updatedAt }) => {
+      var _a;
+      const covered = updatedAt ?? ((_a = rowsRef.current.find((row) => row.threadId === threadId)) == null ? void 0 : _a.updatedAt);
+      setCoveredUpdatedAt((current) => {
+        const next = { ...current };
+        if (covered) next[threadId] = covered;
+        else delete next[threadId];
+        return next;
+      });
+      set({ threadId, value: isUnread });
+    },
+    [set]
+  );
+  return {
+    overrides: field.overrides,
+    coveredUpdatedAt,
+    setReadState,
+    pendingThreadIds: field.pendingThreadIds,
+    isAvailable: field.isAvailable
+  };
+}
+function updatedAfter(row, covered) {
+  if (!covered || !row.updatedAt) return false;
+  const rowAt = Date.parse(row.updatedAt);
+  const coveredAt = Date.parse(covered);
+  return Number.isFinite(rowAt) && Number.isFinite(coveredAt) && rowAt > coveredAt;
+}
+function withReadStateOverrides(rows, overrides, coveredUpdatedAt = {}) {
+  return rows.map((row) => {
+    const override = overrides[row.threadId];
+    if (override === void 0 || override === row.isUnread) return row;
+    if (updatedAfter(row, coveredUpdatedAt[row.threadId])) return row;
+    return { ...row, isUnread: override };
+  });
+}
+exports.useThreadReadState = useThreadReadState;
+exports.withReadStateOverrides = withReadStateOverrides;
+//# sourceMappingURL=use-thread-read-state.cjs.map

package/dist/threads/use-thread-read-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-thread-read-state.cjs","sources":["../../src/threads/use-thread-read-state.ts"],"sourcesContent":["/**\n * Mark a session read or unread for the viewer — the inbox's \"Mark read\" and\n * the session list's read toggle: `useThreadFieldOverride` over\n * `POST /api/conversations/threads/read-state` (see that module for the\n * optimistic-override, rollback, serialization and identity-scoping\n * contract).\n *\n * The override matters more here than for the pin: the read-state route\n * publishes no conversation-index update, so a pushed index entry keeps the\n * `is_unread` it had at the index's last rebuild. The override holds the\n * viewer's answer over that stale push until the sources agree.\n */\nimport { useCallback, useRef, useState } from 'react';\nimport type { CredentialResolver } from '../runtime/credential-renewal';\nimport { setThreadReadState } from './api';\nimport type { RestConversationAuth } from './use-rest-conversation-history';\nimport { type ThreadFieldTarget, useThreadFieldOverride } from './use-thread-field-override';\n\nexport interface ThreadReadStateTarget {\n  threadId: string;\n  isUnread: boolean;\n  /**\n   * The row's last update the receipt covers (its `updatedAt` when the person\n   * acted). Activity newer than that ends the override, so a session read\n   * here turns unread again when it gets a new message — even in a list the\n   * provider's own page does not hold. Without it the provider's page row's\n   * value is used when it has one.\n   */\n  updatedAt?: string;\n}\n\n/** The fields the override layer reads on a list row. */\nexport interface ReadStateRow {\n  threadId: string;\n  isUnread: boolean;\n  updatedAt?: string;\n}\n\nexport interface UseThreadReadStateOptions {\n  backendUrl: string;\n  /** Non-secret identity in the mutation key. */\n  principalId: string;\n  /** Resolved per request; called with `{ force: true }` when the host refuses the token. */\n  getAuth: CredentialResolver<RestConversationAuth>;\n  /** The rows as the list sources report them, BEFORE overrides. */\n  rows: readonly ReadStateRow[];\n  /** Write the server's answer into the list caches. */\n  onServerTruth?: (result: ThreadReadStateTarget) => void;\n}\n\nexport interface ThreadReadStateToggle {\n  /** Optimistic, then server-confirmed, values layered over the list sources, keyed by thread id. */\n  overrides: Readonly<Record<string, boolean>>;\n  /** The `updatedAt` each override covers; a row updated after it shows its own value. */\n  coveredUpdatedAt: Readonly<Record<string, string>>;\n  setReadState: (target: ThreadReadStateTarget) => void;\n  pendingThreadIds: ReadonlySet<string>;\n  /**\n   * Always `true`: every agora the SDK supports has the read-state route, so\n   * a 404 is a session that no longer exists, never a missing route.\n   */\n  isAvailable: boolean;\n}\n\nconst READ_STATE_UNAVAILABLE_WARNING =\n  '[AthenaSDK] This backend has no POST /api/conversations/threads/read-state route; sessions cannot be marked read from here.';\n\n/** The route predates every agora the SDK supports; a rejection is per thread, never \"no route\". */\nconst isReadStateUnavailableError = (): boolean => false;\n\nconst readUnread = (row: ReadStateRow): boolean => row.isUnread;\n\nexport function useThreadReadState({\n  backendUrl,\n  principalId,\n  getAuth,\n  rows,\n  onServerTruth,\n}: UseThreadReadStateOptions): ThreadReadStateToggle {\n  const field = useThreadFieldOverride<boolean, ReadStateRow>({\n    field: 'read-state',\n    backendUrl,\n    principalId,\n    getAuth,\n    rows,\n    readRow: readUnread,\n    write: async (auth, { threadId, value }) => {\n      const result = await setThreadReadState(backendUrl, auth, { threadId, isUnread: value });\n      return { threadId: result.thread_id, value: result.is_unread };\n    },\n    isUnavailableError: isReadStateUnavailableError,\n    unavailableWarning: READ_STATE_UNAVAILABLE_WARNING,\n    onServerTruth: onServerTruth\n      ? ({ threadId, value }: ThreadFieldTarget<boolean>) =>\n          onServerTruth({ threadId, isUnread: value })\n      : undefined,\n  });\n  const set = field.set;\n  const rowsRef = useRef(rows);\n  rowsRef.current = rows;\n  const [coveredUpdatedAt, setCoveredUpdatedAt] = useState<Readonly<Record<string, string>>>({});\n  const setReadState = useCallback(\n    ({ threadId, isUnread, updatedAt }: ThreadReadStateTarget) => {\n      const covered =\n        updatedAt ?? rowsRef.current.find((row) => row.threadId === threadId)?.updatedAt;\n      setCoveredUpdatedAt((current) => {\n        const next = { ...current };\n        if (covered) next[threadId] = covered;\n        else delete next[threadId];\n        return next;\n      });\n      set({ threadId, value: isUnread });\n    },\n    [set],\n  );\n  return {\n    overrides: field.overrides,\n    coveredUpdatedAt,\n    setReadState,\n    pendingThreadIds: field.pendingThreadIds,\n    isAvailable: field.isAvailable,\n  };\n}\n\nfunction updatedAfter(row: ReadStateRow, covered: string | undefined): boolean {\n  if (!covered || !row.updatedAt) return false;\n  const rowAt = Date.parse(row.updatedAt);\n  const coveredAt = Date.parse(covered);\n  return Number.isFinite(rowAt) && Number.isFinite(coveredAt) && rowAt > coveredAt;\n}\n\n/**\n * Every row with its read-state override applied — except a row updated\n * after the activity the override covers, which shows its own value (marking\n * read never moves `updatedAt`, so a newer one is new activity).\n */\nexport function withReadStateOverrides<T extends ReadStateRow>(\n  rows: readonly T[],\n  overrides: Readonly<Record<string, boolean>>,\n  coveredUpdatedAt: Readonly<Record<string, string>> = {},\n): T[] {\n  return rows.map((row) => {\n    const override = overrides[row.threadId];\n    if (override === undefined || override === row.isUnread) return row;\n    if (updatedAfter(row, coveredUpdatedAt[row.threadId])) return row;\n    return { ...row, isUnread: override };\n  });\n}\n"],"names":["useThreadFieldOverride","setThreadReadState","useRef","useState","useCallback"],"mappings":";;;;;AAgEA,MAAM,iCACJ;AAGF,MAAM,8BAA8B,MAAe;AAEnD,MAAM,aAAa,CAAC,QAA+B,IAAI;AAEhD,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAqD;AACnD,QAAM,QAAQA,uBAAAA,uBAA8C;AAAA,IAC1D,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT,OAAO,OAAO,MAAM,EAAE,UAAU,YAAY;AAC1C,YAAM,SAAS,MAAMC,IAAAA,mBAAmB,YAAY,MAAM,EAAE,UAAU,UAAU,OAAO;AACvF,aAAO,EAAE,UAAU,OAAO,WAAW,OAAO,OAAO,UAAA;AAAA,IACrD;AAAA,IACA,oBAAoB;AAAA,IACpB,oBAAoB;AAAA,IACpB,eAAe,gBACX,CAAC,EAAE,UAAU,MAAA,MACX,cAAc,EAAE,UAAU,UAAU,MAAA,CAAO,IAC7C;AAAA,EAAA,CACL;AACD,QAAM,MAAM,MAAM;AAClB,QAAM,UAAUC,MAAAA,OAAO,IAAI;AAC3B,UAAQ,UAAU;AAClB,QAAM,CAAC,kBAAkB,mBAAmB,IAAIC,MAAAA,SAA2C,CAAA,CAAE;AAC7F,QAAM,eAAeC,MAAAA;AAAAA,IACnB,CAAC,EAAE,UAAU,UAAU,gBAAuC;;AAC5D,YAAM,UACJ,eAAa,aAAQ,QAAQ,KAAK,CAAC,QAAQ,IAAI,aAAa,QAAQ,MAAvD,mBAA0D;AACzE,0BAAoB,CAAC,YAAY;AAC/B,cAAM,OAAO,EAAE,GAAG,QAAA;AAClB,YAAI,QAAS,MAAK,QAAQ,IAAI;AAAA,YACzB,QAAO,KAAK,QAAQ;AACzB,eAAO;AAAA,MACT,CAAC;AACD,UAAI,EAAE,UAAU,OAAO,SAAA,CAAU;AAAA,IACnC;AAAA,IACA,CAAC,GAAG;AAAA,EAAA;AAEN,SAAO;AAAA,IACL,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA,kBAAkB,MAAM;AAAA,IACxB,aAAa,MAAM;AAAA,EAAA;AAEvB;AAEA,SAAS,aAAa,KAAmB,SAAsC;AAC7E,MAAI,CAAC,WAAW,CAAC,IAAI,UAAW,QAAO;AACvC,QAAM,QAAQ,KAAK,MAAM,IAAI,SAAS;AACtC,QAAM,YAAY,KAAK,MAAM,OAAO;AACpC,SAAO,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,SAAS,KAAK,QAAQ;AACzE;AAOO,SAAS,uBACd,MACA,WACA,mBAAqD,CAAA,GAChD;AACL,SAAO,KAAK,IAAI,CAAC,QAAQ;AACvB,UAAM,WAAW,UAAU,IAAI,QAAQ;AACvC,QAAI,aAAa,UAAa,aAAa,IAAI,SAAU,QAAO;AAChE,QAAI,aAAa,KAAK,iBAAiB,IAAI,QAAQ,CAAC,EAAG,QAAO;AAC9D,WAAO,EAAE,GAAG,KAAK,UAAU,SAAA;AAAA,EAC7B,CAAC;AACH;;;"}

package/dist/threads/use-thread-read-state.d.ts

@@ -0,0 +1,51 @@
+import type { CredentialResolver } from '../runtime/credential-renewal';
+import type { RestConversationAuth } from './use-rest-conversation-history';
+export interface ThreadReadStateTarget {
+    threadId: string;
+    isUnread: boolean;
+    /**
+     * The row's last update the receipt covers (its `updatedAt` when the person
+     * acted). Activity newer than that ends the override, so a session read
+     * here turns unread again when it gets a new message — even in a list the
+     * provider's own page does not hold. Without it the provider's page row's
+     * value is used when it has one.
+     */
+    updatedAt?: string;
+}
+/** The fields the override layer reads on a list row. */
+export interface ReadStateRow {
+    threadId: string;
+    isUnread: boolean;
+    updatedAt?: string;
+}
+export interface UseThreadReadStateOptions {
+    backendUrl: string;
+    /** Non-secret identity in the mutation key. */
+    principalId: string;
+    /** Resolved per request; called with `{ force: true }` when the host refuses the token. */
+    getAuth: CredentialResolver<RestConversationAuth>;
+    /** The rows as the list sources report them, BEFORE overrides. */
+    rows: readonly ReadStateRow[];
+    /** Write the server's answer into the list caches. */
+    onServerTruth?: (result: ThreadReadStateTarget) => void;
+}
+export interface ThreadReadStateToggle {
+    /** Optimistic, then server-confirmed, values layered over the list sources, keyed by thread id. */
+    overrides: Readonly<Record<string, boolean>>;
+    /** The `updatedAt` each override covers; a row updated after it shows its own value. */
+    coveredUpdatedAt: Readonly<Record<string, string>>;
+    setReadState: (target: ThreadReadStateTarget) => void;
+    pendingThreadIds: ReadonlySet<string>;
+    /**
+     * Always `true`: every agora the SDK supports has the read-state route, so
+     * a 404 is a session that no longer exists, never a missing route.
+     */
+    isAvailable: boolean;
+}
+export declare function useThreadReadState({ backendUrl, principalId, getAuth, rows, onServerTruth, }: UseThreadReadStateOptions): ThreadReadStateToggle;
+/**
+ * Every row with its read-state override applied — except a row updated
+ * after the activity the override covers, which shows its own value (marking
+ * read never moves `updatedAt`, so a newer one is new activity).
+ */
+export declare function withReadStateOverrides<T extends ReadStateRow>(rows: readonly T[], overrides: Readonly<Record<string, boolean>>, coveredUpdatedAt?: Readonly<Record<string, string>>): T[];

package/dist/threads/use-thread-read-state.js

@@ -0,0 +1,73 @@
+import { useRef, useState, useCallback } from "react";
+import { setThreadReadState } from "./api.js";
+import { useThreadFieldOverride } from "./use-thread-field-override.js";
+const READ_STATE_UNAVAILABLE_WARNING = "[AthenaSDK] This backend has no POST /api/conversations/threads/read-state route; sessions cannot be marked read from here.";
+const isReadStateUnavailableError = () => false;
+const readUnread = (row) => row.isUnread;
+function useThreadReadState({
+  backendUrl,
+  principalId,
+  getAuth,
+  rows,
+  onServerTruth
+}) {
+  const field = useThreadFieldOverride({
+    field: "read-state",
+    backendUrl,
+    principalId,
+    getAuth,
+    rows,
+    readRow: readUnread,
+    write: async (auth, { threadId, value }) => {
+      const result = await setThreadReadState(backendUrl, auth, { threadId, isUnread: value });
+      return { threadId: result.thread_id, value: result.is_unread };
+    },
+    isUnavailableError: isReadStateUnavailableError,
+    unavailableWarning: READ_STATE_UNAVAILABLE_WARNING,
+    onServerTruth: onServerTruth ? ({ threadId, value }) => onServerTruth({ threadId, isUnread: value }) : void 0
+  });
+  const set = field.set;
+  const rowsRef = useRef(rows);
+  rowsRef.current = rows;
+  const [coveredUpdatedAt, setCoveredUpdatedAt] = useState({});
+  const setReadState = useCallback(
+    ({ threadId, isUnread, updatedAt }) => {
+      var _a;
+      const covered = updatedAt ?? ((_a = rowsRef.current.find((row) => row.threadId === threadId)) == null ? void 0 : _a.updatedAt);
+      setCoveredUpdatedAt((current) => {
+        const next = { ...current };
+        if (covered) next[threadId] = covered;
+        else delete next[threadId];
+        return next;
+      });
+      set({ threadId, value: isUnread });
+    },
+    [set]
+  );
+  return {
+    overrides: field.overrides,
+    coveredUpdatedAt,
+    setReadState,
+    pendingThreadIds: field.pendingThreadIds,
+    isAvailable: field.isAvailable
+  };
+}
+function updatedAfter(row, covered) {
+  if (!covered || !row.updatedAt) return false;
+  const rowAt = Date.parse(row.updatedAt);
+  const coveredAt = Date.parse(covered);
+  return Number.isFinite(rowAt) && Number.isFinite(coveredAt) && rowAt > coveredAt;
+}
+function withReadStateOverrides(rows, overrides, coveredUpdatedAt = {}) {
+  return rows.map((row) => {
+    const override = overrides[row.threadId];
+    if (override === void 0 || override === row.isUnread) return row;
+    if (updatedAfter(row, coveredUpdatedAt[row.threadId])) return row;
+    return { ...row, isUnread: override };
+  });
+}
+export {
+  useThreadReadState,
+  withReadStateOverrides
+};
+//# sourceMappingURL=use-thread-read-state.js.map

package/dist/threads/use-thread-read-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-thread-read-state.js","sources":["../../src/threads/use-thread-read-state.ts"],"sourcesContent":["/**\n * Mark a session read or unread for the viewer — the inbox's \"Mark read\" and\n * the session list's read toggle: `useThreadFieldOverride` over\n * `POST /api/conversations/threads/read-state` (see that module for the\n * optimistic-override, rollback, serialization and identity-scoping\n * contract).\n *\n * The override matters more here than for the pin: the read-state route\n * publishes no conversation-index update, so a pushed index entry keeps the\n * `is_unread` it had at the index's last rebuild. The override holds the\n * viewer's answer over that stale push until the sources agree.\n */\nimport { useCallback, useRef, useState } from 'react';\nimport type { CredentialResolver } from '../runtime/credential-renewal';\nimport { setThreadReadState } from './api';\nimport type { RestConversationAuth } from './use-rest-conversation-history';\nimport { type ThreadFieldTarget, useThreadFieldOverride } from './use-thread-field-override';\n\nexport interface ThreadReadStateTarget {\n  threadId: string;\n  isUnread: boolean;\n  /**\n   * The row's last update the receipt covers (its `updatedAt` when the person\n   * acted). Activity newer than that ends the override, so a session read\n   * here turns unread again when it gets a new message — even in a list the\n   * provider's own page does not hold. Without it the provider's page row's\n   * value is used when it has one.\n   */\n  updatedAt?: string;\n}\n\n/** The fields the override layer reads on a list row. */\nexport interface ReadStateRow {\n  threadId: string;\n  isUnread: boolean;\n  updatedAt?: string;\n}\n\nexport interface UseThreadReadStateOptions {\n  backendUrl: string;\n  /** Non-secret identity in the mutation key. */\n  principalId: string;\n  /** Resolved per request; called with `{ force: true }` when the host refuses the token. */\n  getAuth: CredentialResolver<RestConversationAuth>;\n  /** The rows as the list sources report them, BEFORE overrides. */\n  rows: readonly ReadStateRow[];\n  /** Write the server's answer into the list caches. */\n  onServerTruth?: (result: ThreadReadStateTarget) => void;\n}\n\nexport interface ThreadReadStateToggle {\n  /** Optimistic, then server-confirmed, values layered over the list sources, keyed by thread id. */\n  overrides: Readonly<Record<string, boolean>>;\n  /** The `updatedAt` each override covers; a row updated after it shows its own value. */\n  coveredUpdatedAt: Readonly<Record<string, string>>;\n  setReadState: (target: ThreadReadStateTarget) => void;\n  pendingThreadIds: ReadonlySet<string>;\n  /**\n   * Always `true`: every agora the SDK supports has the read-state route, so\n   * a 404 is a session that no longer exists, never a missing route.\n   */\n  isAvailable: boolean;\n}\n\nconst READ_STATE_UNAVAILABLE_WARNING =\n  '[AthenaSDK] This backend has no POST /api/conversations/threads/read-state route; sessions cannot be marked read from here.';\n\n/** The route predates every agora the SDK supports; a rejection is per thread, never \"no route\". */\nconst isReadStateUnavailableError = (): boolean => false;\n\nconst readUnread = (row: ReadStateRow): boolean => row.isUnread;\n\nexport function useThreadReadState({\n  backendUrl,\n  principalId,\n  getAuth,\n  rows,\n  onServerTruth,\n}: UseThreadReadStateOptions): ThreadReadStateToggle {\n  const field = useThreadFieldOverride<boolean, ReadStateRow>({\n    field: 'read-state',\n    backendUrl,\n    principalId,\n    getAuth,\n    rows,\n    readRow: readUnread,\n    write: async (auth, { threadId, value }) => {\n      const result = await setThreadReadState(backendUrl, auth, { threadId, isUnread: value });\n      return { threadId: result.thread_id, value: result.is_unread };\n    },\n    isUnavailableError: isReadStateUnavailableError,\n    unavailableWarning: READ_STATE_UNAVAILABLE_WARNING,\n    onServerTruth: onServerTruth\n      ? ({ threadId, value }: ThreadFieldTarget<boolean>) =>\n          onServerTruth({ threadId, isUnread: value })\n      : undefined,\n  });\n  const set = field.set;\n  const rowsRef = useRef(rows);\n  rowsRef.current = rows;\n  const [coveredUpdatedAt, setCoveredUpdatedAt] = useState<Readonly<Record<string, string>>>({});\n  const setReadState = useCallback(\n    ({ threadId, isUnread, updatedAt }: ThreadReadStateTarget) => {\n      const covered =\n        updatedAt ?? rowsRef.current.find((row) => row.threadId === threadId)?.updatedAt;\n      setCoveredUpdatedAt((current) => {\n        const next = { ...current };\n        if (covered) next[threadId] = covered;\n        else delete next[threadId];\n        return next;\n      });\n      set({ threadId, value: isUnread });\n    },\n    [set],\n  );\n  return {\n    overrides: field.overrides,\n    coveredUpdatedAt,\n    setReadState,\n    pendingThreadIds: field.pendingThreadIds,\n    isAvailable: field.isAvailable,\n  };\n}\n\nfunction updatedAfter(row: ReadStateRow, covered: string | undefined): boolean {\n  if (!covered || !row.updatedAt) return false;\n  const rowAt = Date.parse(row.updatedAt);\n  const coveredAt = Date.parse(covered);\n  return Number.isFinite(rowAt) && Number.isFinite(coveredAt) && rowAt > coveredAt;\n}\n\n/**\n * Every row with its read-state override applied — except a row updated\n * after the activity the override covers, which shows its own value (marking\n * read never moves `updatedAt`, so a newer one is new activity).\n */\nexport function withReadStateOverrides<T extends ReadStateRow>(\n  rows: readonly T[],\n  overrides: Readonly<Record<string, boolean>>,\n  coveredUpdatedAt: Readonly<Record<string, string>> = {},\n): T[] {\n  return rows.map((row) => {\n    const override = overrides[row.threadId];\n    if (override === undefined || override === row.isUnread) return row;\n    if (updatedAfter(row, coveredUpdatedAt[row.threadId])) return row;\n    return { ...row, isUnread: override };\n  });\n}\n"],"names":[],"mappings":";;;AAgEA,MAAM,iCACJ;AAGF,MAAM,8BAA8B,MAAe;AAEnD,MAAM,aAAa,CAAC,QAA+B,IAAI;AAEhD,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAqD;AACnD,QAAM,QAAQ,uBAA8C;AAAA,IAC1D,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT,OAAO,OAAO,MAAM,EAAE,UAAU,YAAY;AAC1C,YAAM,SAAS,MAAM,mBAAmB,YAAY,MAAM,EAAE,UAAU,UAAU,OAAO;AACvF,aAAO,EAAE,UAAU,OAAO,WAAW,OAAO,OAAO,UAAA;AAAA,IACrD;AAAA,IACA,oBAAoB;AAAA,IACpB,oBAAoB;AAAA,IACpB,eAAe,gBACX,CAAC,EAAE,UAAU,MAAA,MACX,cAAc,EAAE,UAAU,UAAU,MAAA,CAAO,IAC7C;AAAA,EAAA,CACL;AACD,QAAM,MAAM,MAAM;AAClB,QAAM,UAAU,OAAO,IAAI;AAC3B,UAAQ,UAAU;AAClB,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,SAA2C,CAAA,CAAE;AAC7F,QAAM,eAAe;AAAA,IACnB,CAAC,EAAE,UAAU,UAAU,gBAAuC;;AAC5D,YAAM,UACJ,eAAa,aAAQ,QAAQ,KAAK,CAAC,QAAQ,IAAI,aAAa,QAAQ,MAAvD,mBAA0D;AACzE,0BAAoB,CAAC,YAAY;AAC/B,cAAM,OAAO,EAAE,GAAG,QAAA;AAClB,YAAI,QAAS,MAAK,QAAQ,IAAI;AAAA,YACzB,QAAO,KAAK,QAAQ;AACzB,eAAO;AAAA,MACT,CAAC;AACD,UAAI,EAAE,UAAU,OAAO,SAAA,CAAU;AAAA,IACnC;AAAA,IACA,CAAC,GAAG;AAAA,EAAA;AAEN,SAAO;AAAA,IACL,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA,kBAAkB,MAAM;AAAA,IACxB,aAAa,MAAM;AAAA,EAAA;AAEvB;AAEA,SAAS,aAAa,KAAmB,SAAsC;AAC7E,MAAI,CAAC,WAAW,CAAC,IAAI,UAAW,QAAO;AACvC,QAAM,QAAQ,KAAK,MAAM,IAAI,SAAS;AACtC,QAAM,YAAY,KAAK,MAAM,OAAO;AACpC,SAAO,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,SAAS,KAAK,QAAQ;AACzE;AAOO,SAAS,uBACd,MACA,WACA,mBAAqD,CAAA,GAChD;AACL,SAAO,KAAK,IAAI,CAAC,QAAQ;AACvB,UAAM,WAAW,UAAU,IAAI,QAAQ;AACvC,QAAI,aAAa,UAAa,aAAa,IAAI,SAAU,QAAO;AAChE,QAAI,aAAa,KAAK,iBAAiB,IAAI,QAAQ,CAAC,EAAG,QAAO;AAC9D,WAAO,EAAE,GAAG,KAAK,UAAU,SAAA;AAAA,EAC7B,CAAC;AACH;"}

package/dist/tiptap-markdown-table/src/markdown-table-serializer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-table-serializer.cjs","sources":["../../../../tiptap-markdown-table/src/markdown-table-serializer.ts"],"sourcesContent":["/**\n * The table writer every Tiptap editor that writes Markdown through\n * tiptap-markdown shares: Olympus's docs `TableNode` and Skill editor, and the\n * `@athenaintel/react` chat composer's `ChatTableExtension`. A table node takes\n * it through {@link markdownTableStorage}.\n */\nimport { type Editor, getHTMLFromFragment } from \"@tiptap/core\";\nimport { Fragment, type Node as ProseMirrorNode } from \"@tiptap/pm/model\";\n\n/**\n * A table cell's markdown with each `|` escaped, so none of them ends the cell.\n * GFM ends a cell at every unescaped pipe, inside a code span or a link target\n * too; markdown-it drops the backslash of each `\\|` as it splits the row, so the\n * cell (and any code span in it) reads back with its literal pipe. The AOP\n * converter's markdown read escapes cells the same way\n * (`agora/converter-olympus/src/utils/turndown-helpers.ts`).\n */\nexport function escapeTableCellPipes(markdown: string): string {\n  return markdown.replace(/\\|/g, \"\\\\|\");\n}\n\n/**\n * What the table serializer uses of tiptap-markdown's serializer state:\n * prosemirror-markdown's `MarkdownSerializerState` plus tiptap-markdown's\n * `inTable` flag, which makes a hard break inside a cell write `<br>`.\n */\ninterface MarkdownTableSerializerState {\n  out: string;\n  inTable: boolean;\n  write(content?: string): void;\n  text(text: string, escapeMarkdown?: boolean): void;\n  ensureNewLine(): void;\n  closeBlock(node: ProseMirrorNode): void;\n  renderInline(parent: ProseMirrorNode, fromBlockStart?: boolean): void;\n}\n\n/** The `this` tiptap-markdown binds a node's `serialize` to. */\ninterface MarkdownSpecContext {\n  editor: Editor;\n}\n\n/**\n * tiptap-markdown's `html` option, from the storage it keeps in\n * `editor.storage.markdown`. Tiptap 3 types `editor.storage` as an interface\n * each extension augments, and tiptap-markdown's own typings declare only\n * `getMarkdown()`, so the option is read through a guard rather than by\n * augmenting `@tiptap/core` for every editor that imports this module. Throws\n * when tiptap-markdown is not registered on the editor.\n */\nfunction markdownHtmlOption(editor: Editor): boolean {\n  const storage: unknown = Reflect.get(editor.storage, \"markdown\");\n  const options: unknown =\n    typeof storage === \"object\" && storage !== null ? Reflect.get(storage, \"options\") : undefined;\n  const html: unknown =\n    typeof options === \"object\" && options !== null ? Reflect.get(options, \"html\") : undefined;\n  if (typeof html !== \"boolean\") {\n    throw new Error(\"tiptap-markdown is not registered on this editor\");\n  }\n  return html;\n}\n\n/**\n * Renders a cell's inline content with every `|` it writes escaped. Everything\n * a cell's inline content writes goes through the state's `text` (text, code\n * spans, mark delimiters, link targets) or `write` (inline nodes such as\n * mentions, images and inline HTML), so both are wrapped for the cell and\n * restored after it. Escaping as the output is written, not afterwards, keeps\n * the output offsets tiptap-markdown records to move emphasis delimiters in\n * step with the output.\n */\nfunction renderCellInline({\n  state,\n  cellContent,\n}: {\n  state: MarkdownTableSerializerState;\n  cellContent: ProseMirrorNode;\n}): void {\n  const { text, write } = state;\n  state.text = (content, escapeMarkdown) => {\n    const start = state.out.length;\n    text.call(state, content, escapeMarkdown);\n    state.out = state.out.slice(0, start) + escapeTableCellPipes(state.out.slice(start));\n  };\n  state.write = (content) => {\n    write.call(state, content === undefined ? content : escapeTableCellPipes(content));\n  };\n  try {\n    state.renderInline(cellContent);\n  } finally {\n    state.text = text;\n    state.write = write;\n  }\n}\n\nfunction hasSpan(cell: ProseMirrorNode): boolean {\n  return cell.attrs.colspan > 1 || cell.attrs.rowspan > 1;\n}\n\n/**\n * A GFM pipe table holds one header row of single-paragraph header cells over\n * body rows of single-paragraph data cells, with no merged cells. Any other\n * table is written as HTML.\n */\nfunction isMarkdownSerializable(table: ProseMirrorNode): boolean {\n  const [firstRow, ...bodyRows] = table.children;\n  const headerCells = firstRow?.children ?? [];\n  if (\n    headerCells.some(\n      (cell) => cell.type.name !== \"tableHeader\" || hasSpan(cell) || cell.childCount > 1,\n    )\n  ) {\n    return false;\n  }\n  return !bodyRows.some((row) =>\n    row.children.some(\n      (cell) => cell.type.name === \"tableHeader\" || hasSpan(cell) || cell.childCount > 1,\n    ),\n  );\n}\n\n/** An HTML block as CommonMark reads one: the element's content on lines of its own. */\nfunction formatHtmlBlock(html: string): string {\n  const body = new window.DOMParser().parseFromString(`<body>${html}</body>`, \"text/html\").body;\n  const element = body.firstElementChild;\n  if (!element) return html;\n  element.innerHTML = element.innerHTML.trim() ? `\\n${element.innerHTML}\\n` : \"\\n\";\n  return element.outerHTML;\n}\n\nfunction serializeTableAsHtml({\n  editor,\n  state,\n  node,\n  parent,\n}: {\n  editor: Editor;\n  state: MarkdownTableSerializerState;\n  node: ProseMirrorNode;\n  parent: ProseMirrorNode | Fragment;\n}): void {\n  if (markdownHtmlOption(editor)) {\n    const { schema } = node.type;\n    const html = getHTMLFromFragment(Fragment.from(node), schema);\n    const isTopLevel = parent instanceof Fragment || parent.type.name === schema.topNodeType.name;\n    state.write(isTopLevel ? formatHtmlBlock(html) : html);\n  } else {\n    console.warn(`Tiptap Markdown: \"${node.type.name}\" node is only available in html mode`);\n    state.write(`[${node.type.name}]`);\n  }\n  state.closeBlock(node);\n}\n\n/**\n * tiptap-markdown 0.9.0's table serializer, except that a `|` inside a cell is\n * written as `\\|` (see {@link escapeTableCellPipes}). The library writes it\n * bare — it escapes only `<` / `>` in text, and prosemirror-markdown only\n * `` `*\\~[]_ `` — so a cell holding `a | b` or `` `x|y` `` read back as extra\n * columns and markdown-it dropped every cell past the header's width. A table\n * that is not a GFM pipe table is still written as HTML, and everything else is\n * written exactly as the library writes it.\n */\nexport function serializeMarkdownTable(\n  this: MarkdownSpecContext,\n  state: MarkdownTableSerializerState,\n  node: ProseMirrorNode,\n  parent: ProseMirrorNode | Fragment,\n): void {\n  if (!isMarkdownSerializable(node)) {\n    serializeTableAsHtml({ editor: this.editor, state, node, parent });\n    return;\n  }\n  state.inTable = true;\n  node.forEach((row, _rowOffset, rowIndex) => {\n    state.write(\"| \");\n    row.forEach((cell, _cellOffset, cellIndex) => {\n      if (cellIndex) {\n        state.write(\" | \");\n      }\n      const cellContent = cell.firstChild;\n      if (cellContent?.textContent.trim()) {\n        renderCellInline({ state, cellContent });\n      }\n    });\n    state.write(\" |\");\n    state.ensureNewLine();\n    if (!rowIndex) {\n      const delimiterRow = Array.from({ length: row.childCount }, () => \"---\").join(\" | \");\n      state.write(`| ${delimiterRow} |`);\n      state.ensureNewLine();\n    }\n  });\n  state.closeBlock(node);\n  state.inTable = false;\n}\n\n/**\n * The storage that makes tiptap-markdown serialize a table node with\n * {@link serializeMarkdownTable}: tiptap-markdown reads a node's markdown spec\n * from `storage.markdown`, over its own spec for the node's name.\n */\nexport function markdownTableStorage(): {\n  markdown: { serialize: typeof serializeMarkdownTable };\n} {\n  return { markdown: { serialize: serializeMarkdownTable } };\n}\n"],"names":["getHTMLFromFragment","Fragment"],"mappings":"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"}

package/dist/tiptap-markdown-table/src/markdown-table-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-table-serializer.js","sources":["../../../../tiptap-markdown-table/src/markdown-table-serializer.ts"],"sourcesContent":["/**\n * The table writer every Tiptap editor that writes Markdown through\n * tiptap-markdown shares: Olympus's docs `TableNode` and Skill editor, and the\n * `@athenaintel/react` chat composer's `ChatTableExtension`. A table node takes\n * it through {@link markdownTableStorage}.\n */\nimport { type Editor, getHTMLFromFragment } from \"@tiptap/core\";\nimport { Fragment, type Node as ProseMirrorNode } from \"@tiptap/pm/model\";\n\n/**\n * A table cell's markdown with each `|` escaped, so none of them ends the cell.\n * GFM ends a cell at every unescaped pipe, inside a code span or a link target\n * too; markdown-it drops the backslash of each `\\|` as it splits the row, so the\n * cell (and any code span in it) reads back with its literal pipe. The AOP\n * converter's markdown read escapes cells the same way\n * (`agora/converter-olympus/src/utils/turndown-helpers.ts`).\n */\nexport function escapeTableCellPipes(markdown: string): string {\n  return markdown.replace(/\\|/g, \"\\\\|\");\n}\n\n/**\n * What the table serializer uses of tiptap-markdown's serializer state:\n * prosemirror-markdown's `MarkdownSerializerState` plus tiptap-markdown's\n * `inTable` flag, which makes a hard break inside a cell write `<br>`.\n */\ninterface MarkdownTableSerializerState {\n  out: string;\n  inTable: boolean;\n  write(content?: string): void;\n  text(text: string, escapeMarkdown?: boolean): void;\n  ensureNewLine(): void;\n  closeBlock(node: ProseMirrorNode): void;\n  renderInline(parent: ProseMirrorNode, fromBlockStart?: boolean): void;\n}\n\n/** The `this` tiptap-markdown binds a node's `serialize` to. */\ninterface MarkdownSpecContext {\n  editor: Editor;\n}\n\n/**\n * tiptap-markdown's `html` option, from the storage it keeps in\n * `editor.storage.markdown`. Tiptap 3 types `editor.storage` as an interface\n * each extension augments, and tiptap-markdown's own typings declare only\n * `getMarkdown()`, so the option is read through a guard rather than by\n * augmenting `@tiptap/core` for every editor that imports this module. Throws\n * when tiptap-markdown is not registered on the editor.\n */\nfunction markdownHtmlOption(editor: Editor): boolean {\n  const storage: unknown = Reflect.get(editor.storage, \"markdown\");\n  const options: unknown =\n    typeof storage === \"object\" && storage !== null ? Reflect.get(storage, \"options\") : undefined;\n  const html: unknown =\n    typeof options === \"object\" && options !== null ? Reflect.get(options, \"html\") : undefined;\n  if (typeof html !== \"boolean\") {\n    throw new Error(\"tiptap-markdown is not registered on this editor\");\n  }\n  return html;\n}\n\n/**\n * Renders a cell's inline content with every `|` it writes escaped. Everything\n * a cell's inline content writes goes through the state's `text` (text, code\n * spans, mark delimiters, link targets) or `write` (inline nodes such as\n * mentions, images and inline HTML), so both are wrapped for the cell and\n * restored after it. Escaping as the output is written, not afterwards, keeps\n * the output offsets tiptap-markdown records to move emphasis delimiters in\n * step with the output.\n */\nfunction renderCellInline({\n  state,\n  cellContent,\n}: {\n  state: MarkdownTableSerializerState;\n  cellContent: ProseMirrorNode;\n}): void {\n  const { text, write } = state;\n  state.text = (content, escapeMarkdown) => {\n    const start = state.out.length;\n    text.call(state, content, escapeMarkdown);\n    state.out = state.out.slice(0, start) + escapeTableCellPipes(state.out.slice(start));\n  };\n  state.write = (content) => {\n    write.call(state, content === undefined ? content : escapeTableCellPipes(content));\n  };\n  try {\n    state.renderInline(cellContent);\n  } finally {\n    state.text = text;\n    state.write = write;\n  }\n}\n\nfunction hasSpan(cell: ProseMirrorNode): boolean {\n  return cell.attrs.colspan > 1 || cell.attrs.rowspan > 1;\n}\n\n/**\n * A GFM pipe table holds one header row of single-paragraph header cells over\n * body rows of single-paragraph data cells, with no merged cells. Any other\n * table is written as HTML.\n */\nfunction isMarkdownSerializable(table: ProseMirrorNode): boolean {\n  const [firstRow, ...bodyRows] = table.children;\n  const headerCells = firstRow?.children ?? [];\n  if (\n    headerCells.some(\n      (cell) => cell.type.name !== \"tableHeader\" || hasSpan(cell) || cell.childCount > 1,\n    )\n  ) {\n    return false;\n  }\n  return !bodyRows.some((row) =>\n    row.children.some(\n      (cell) => cell.type.name === \"tableHeader\" || hasSpan(cell) || cell.childCount > 1,\n    ),\n  );\n}\n\n/** An HTML block as CommonMark reads one: the element's content on lines of its own. */\nfunction formatHtmlBlock(html: string): string {\n  const body = new window.DOMParser().parseFromString(`<body>${html}</body>`, \"text/html\").body;\n  const element = body.firstElementChild;\n  if (!element) return html;\n  element.innerHTML = element.innerHTML.trim() ? `\\n${element.innerHTML}\\n` : \"\\n\";\n  return element.outerHTML;\n}\n\nfunction serializeTableAsHtml({\n  editor,\n  state,\n  node,\n  parent,\n}: {\n  editor: Editor;\n  state: MarkdownTableSerializerState;\n  node: ProseMirrorNode;\n  parent: ProseMirrorNode | Fragment;\n}): void {\n  if (markdownHtmlOption(editor)) {\n    const { schema } = node.type;\n    const html = getHTMLFromFragment(Fragment.from(node), schema);\n    const isTopLevel = parent instanceof Fragment || parent.type.name === schema.topNodeType.name;\n    state.write(isTopLevel ? formatHtmlBlock(html) : html);\n  } else {\n    console.warn(`Tiptap Markdown: \"${node.type.name}\" node is only available in html mode`);\n    state.write(`[${node.type.name}]`);\n  }\n  state.closeBlock(node);\n}\n\n/**\n * tiptap-markdown 0.9.0's table serializer, except that a `|` inside a cell is\n * written as `\\|` (see {@link escapeTableCellPipes}). The library writes it\n * bare — it escapes only `<` / `>` in text, and prosemirror-markdown only\n * `` `*\\~[]_ `` — so a cell holding `a | b` or `` `x|y` `` read back as extra\n * columns and markdown-it dropped every cell past the header's width. A table\n * that is not a GFM pipe table is still written as HTML, and everything else is\n * written exactly as the library writes it.\n */\nexport function serializeMarkdownTable(\n  this: MarkdownSpecContext,\n  state: MarkdownTableSerializerState,\n  node: ProseMirrorNode,\n  parent: ProseMirrorNode | Fragment,\n): void {\n  if (!isMarkdownSerializable(node)) {\n    serializeTableAsHtml({ editor: this.editor, state, node, parent });\n    return;\n  }\n  state.inTable = true;\n  node.forEach((row, _rowOffset, rowIndex) => {\n    state.write(\"| \");\n    row.forEach((cell, _cellOffset, cellIndex) => {\n      if (cellIndex) {\n        state.write(\" | \");\n      }\n      const cellContent = cell.firstChild;\n      if (cellContent?.textContent.trim()) {\n        renderCellInline({ state, cellContent });\n      }\n    });\n    state.write(\" |\");\n    state.ensureNewLine();\n    if (!rowIndex) {\n      const delimiterRow = Array.from({ length: row.childCount }, () => \"---\").join(\" | \");\n      state.write(`| ${delimiterRow} |`);\n      state.ensureNewLine();\n    }\n  });\n  state.closeBlock(node);\n  state.inTable = false;\n}\n\n/**\n * The storage that makes tiptap-markdown serialize a table node with\n * {@link serializeMarkdownTable}: tiptap-markdown reads a node's markdown spec\n * from `storage.markdown`, over its own spec for the node's name.\n */\nexport function markdownTableStorage(): {\n  markdown: { serialize: typeof serializeMarkdownTable };\n} {\n  return { markdown: { serialize: serializeMarkdownTable } };\n}\n"],"names":[],"mappings":"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"}

package/dist/tools/auto-open-tools.cjs

@@ -45,6 +45,8 @@ const autoOpen = (assetId, options = {}) => {
   const keepCurrentSlide = options.preserveExistingSlide && existing;
   store.openAsset(assetId, {
     type: options.type ?? "unknown",
+    // A host's own opener tells an open nobody clicked from one the person asked for.
+    origin: "auto",
     ...keepCurrentSlide || options.slideNumber === void 0 ? {} : { slideNumber: options.slideNumber }
   });
 };