@athenaintel/react 0.18.0 → 0.19.0

package/dist/chat/super-grouping/activity-timeline.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The assistant turn's activity timeline — the one derivation of "what did
+ * this turn do, and how did each step end" behind the grouped
+ * ("conversational") view on every surface: the SDK's `AthenaChat`, Olympus's
+ * Spaces chat, and the Chrome extension. Pure functions over assistant-ui
+ * message parts; `SuperGroupingCard` renders them.
+ *
+ * Step states come from the shared classifier (`classifyToolResult`) plus the
+ * approval outcomes a part carries (`approval`, `interrupt`, a rejection
+ * result), so a call that reads as failed, paused, or rejected on one surface
+ * cannot read as a green check on another. Copy comes from the shared tool
+ * display registry (`toolStatusLabel`).
+ */
+import type { MessageStatus, ThreadAssistantMessagePart } from '@assistant-ui/react';
+import { type ToolStatusLabelState } from '@athenaintel/agent-runtime';
+import type { GroupingFunction } from './grouping-function';
+export type ActivityToolState = ToolStatusLabelState;
+export type ActivityItem = {
+    kind: 'reasoning';
+    text: string;
+    state: 'running' | 'complete';
+} | {
+    kind: 'tool';
+    toolName: string;
+    state: ActivityToolState;
+};
+/** The turn as a whole: still working, parked on the person, ended in error, or done. */
+export type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';
+type ToolCallPart = Extract<ThreadAssistantMessagePart, {
+    type: 'tool-call';
+}>;
+export interface ActivityTimelineOptions {
+    /**
+     * Tools whose unresolved call means the turn is waiting on the person even
+     * without an interrupt or approval on the part (the Chrome extension's
+     * device plan approval, which the tool UI itself collects).
+     */
+    waitingTools?: ReadonlySet<string>;
+    /**
+     * Tools whose result is an application payload relayed verbatim (the Chrome
+     * extension's page JavaScript), so a `success: false` flag counts only with
+     * an error detail — see `classifyToolResult`'s `passThroughPayload`.
+     */
+    passThroughTools?: ReadonlySet<string>;
+}
+/** How one tool call ended (or is going), reading the approval fields before the result. */
+export declare function getActivityToolState(part: ToolCallPart, messageStatus: MessageStatus | undefined, { waitingTools, passThroughTools }?: ActivityTimelineOptions): ActivityToolState;
+/**
+ * The compact reasoning/tool timeline in the order the parts streamed.
+ *
+ * A reasoning part is still streaming only while it is the final part of a
+ * running message — once any later part appears, the thought has settled.
+ * Settled reasoning parts with no text are dropped so the list never shows an
+ * empty thinking row.
+ */
+export declare function buildActivityTimeline(content: readonly ThreadAssistantMessagePart[] | undefined, messageStatus: MessageStatus | undefined, options?: ActivityTimelineOptions): ActivityItem[];
+/** Number of tool calls in the timeline. */
+export declare function countActivityTools(timeline: readonly ActivityItem[]): number;
+/**
+ * The turn's phase. Waiting on the person wins over everything (a host can
+ * also assert it — Olympus's allotment store knows about `ask`), then the
+ * message's own status.
+ */
+export declare function resolveActivityPhase(status: MessageStatus | undefined, timeline: readonly ActivityItem[], { waitingForInput }?: {
+    waitingForInput?: boolean;
+}): ActivityPhase;
+/**
+ * The status-row copy for one step. `resolveToolDisplayName` lets a host with
+ * a richer tool catalog name tools the shared registry has no entry for.
+ */
+export declare function getActivityItemLabel(item: ActivityItem, resolveToolDisplayName?: (toolName: string) => string | undefined): string;
+/** The collapsed-card summary of a finished turn. */
+export declare function getActivitySummary(timeline: readonly ActivityItem[]): string;
+/** The part shape the final-text read needs; any message role's parts satisfy it. */
+export type FinalTextPart = {
+    readonly type: string;
+    readonly text?: string;
+};
+/**
+ * The visible answer of a grouped turn: the text after the final tool call,
+ * or all of it when the turn never called a tool. Intermediate text (before
+ * or between tool calls) stays available in the details panel.
+ */
+export declare function getFinalText(content: readonly FinalTextPart[] | undefined): string | null;
+/**
+ * Keep the final answer out of the details panel: it renders below the card
+ * (`SuperGroupingFinalText`), so the details grouping drops every text part
+ * after the last tool call and any group that becomes empty.
+ */
+export declare function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction;
+export {};

package/dist/chat/super-grouping/grouping-function.d.ts

@@ -1,19 +1,22 @@
 import type { GetToolGroupKey } from './toolkit-map';
-type AnyPart = {
+/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */
+export type GroupablePart = {
     type: string;
     toolName?: string;
 };
-type MessagePartGroup = {
+/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */
+export type MessagePartGroup = {
     groupKey: string | undefined;
     indices: number[];
 };
+/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */
+export type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];
 /**
- * Ported from Olympus `toolBasedGroupingFunction` in
- * `olympus/src/utils/assistantGrouping.ts`. Groups adjacent parts by their
- * toolkit group key, lets reasoning parts join the active group, and pulls
- * text parts into a group when both surrounding tool-call groups share the
- * same key. Returns the group descriptor that `MessagePrimitive.Unstable_PartsGrouped`
- * consumes.
+ * Groups adjacent parts by their toolkit group key: reasoning parts join the
+ * open group, and a text part joins when the tool calls on both sides of it
+ * share a key. Every `getToolGroupKey` call sees the open group's key and the
+ * set of tools the message called, so a tool shared by several toolkits can
+ * resolve to the one actually in play (Olympus attributes shared citation
+ * tools to the enabled toolkit that way).
  */
-export declare const createToolBasedGroupingFunction: (getToolGroupKey: GetToolGroupKey) => (parts: readonly AnyPart[]) => MessagePartGroup[];
-export {};
+export declare const createToolBasedGroupingFunction: (getToolGroupKey: GetToolGroupKey) => GroupingFunction;

package/dist/chat/super-grouping/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@athenaintel/react/super-grouping` — the grouped ("conversational") view of
+ * an assistant turn: the activity card, its per-toolkit collapsible blocks,
+ * the timeline derivation behind them, and the tool-based grouping function.
+ * A lean entry so hosts with their own thread (Olympus, the Chrome extension)
+ * mount it from source without the SDK's composer stack.
+ */
+export { type ActivityItem, type ActivityPhase, type ActivityTimelineOptions, type ActivityToolState, buildActivityTimeline, countActivityTools, excludeFinalTextFromGroups, type FinalTextPart, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, resolveActivityPhase, } from './activity-timeline';
+export { CollapsibleGroup, type CollapsibleGroupProps, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES, type ToolkitTheme, } from './CollapsibleGroup';
+export { createToolBasedGroupingFunction, type GroupablePart, type GroupingFunction, type MessagePartGroup, } from './grouping-function';
+export { resetRememberedExpansionsForTests, SuperGroupingCard, type SuperGroupingCardProps, SuperGroupingFinalText, useActivityExpansion, } from './SuperGroupingCard';
+export { defaultGetToolGroupKey, type GetToolGroupKey, type ToolGroupKeyOptions } from './toolkit-map';

package/dist/chat/super-grouping/toolkit-map.d.ts

@@ -1,6 +1,12 @@
 export type ToolGroupKeyOptions = {
     /** Display name of the surrounding group, when one is already open. */
     preferredGroupKey?: string;
+    /**
+     * Distinct tool names the message called. Hosts with a toolkit catalog use
+     * it to attribute a tool shared by several toolkits to the one the message
+     * leans on; the default map ignores it.
+     */
+    calledToolNames?: ReadonlySet<string>;
 };
 /**
  * Default `getToolGroupKey` implementation used by the SDK's tool grouping.
@@ -8,7 +14,8 @@ export type ToolGroupKeyOptions = {
  * is ungrouped or unknown. Context-only tools inherit the surrounding group
  * and are otherwise ungrouped.
  *
- * Override per-app by passing `getToolGroupKey` to `<AthenaChat>`.
+ * Override per-app by passing `getToolGroupKey` (or a whole `groupingFunction`) to
+ * `SuperGroupingCard`.
  */
 export declare const defaultGetToolGroupKey: (toolName: string, options?: ToolGroupKeyOptions) => string | undefined;
 export type GetToolGroupKey = (toolName: string, options?: ToolGroupKeyOptions) => string | undefined;

package/dist/chat/use-statewire-approval-request.d.ts

@@ -0,0 +1,44 @@
+import type { StatewireThread } from '@assistant-ui/react-statewire';
+import { type AbandonedInputRequest, type HitlApprovalPayload, type PendingActionRequest } from '@athenaintel/agent-runtime';
+/** Selects which pending interrupt an approval surface answers. */
+export type StatewireInterruptPredicate = (request: StatewireThread.InputRequestState) => request is StatewireThread.CustomInputRequest;
+export interface UseStatewireApprovalRequestOptions {
+    /**
+     * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`
+     * (client-tool parks excluded — the client-tool bridge owns those, and a
+     * generic resume would corrupt the parked tool call).
+     */
+    interruptPredicate?: StatewireInterruptPredicate;
+    /**
+     * How long a sent decision keeps the actions locked when no resume run ever
+     * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.
+     */
+    pendingResumeGraceMs?: number;
+}
+export interface StatewireApprovalRequest<TValue> {
+    /** The pending interrupt this surface answers, if any. */
+    request: StatewireThread.CustomInputRequest | undefined;
+    requestId: string | undefined;
+    /** The payload narrowed to the Athena HITL approval shape, or `null`. */
+    hitl: HitlApprovalPayload | null;
+    /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */
+    actionRequests: PendingActionRequest[];
+    /** An interrupt a non-resume dispatch dropped — the "approval was cancelled" notice. */
+    abandonedInterrupt: AbandonedInputRequest | undefined;
+    /** True after a resume until the request identity changes (or recovery fires). */
+    pending: boolean;
+    /** Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`. */
+    resume: (value: TValue) => void;
+}
+/**
+ * The headless half of every statewire approval surface: selects the pending
+ * interrupt from the runs projection, narrows its payload, reads the
+ * host-published abandoned interrupts, and wires the shared optimistic resume
+ * lock to the thread's `run/input` command. `StatewireApprovalCard` renders
+ * over it; hosts with their own decision UI (per-lane subagent cards) build
+ * on it directly so the selection and lock semantics cannot drift.
+ *
+ * Requires a statewire aui scope (throws outside one, like every
+ * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.
+ */
+export declare function useStatewireApprovalRequest<TValue extends StatewireThread.InputResponse = Record<string, string>>(options?: UseStatewireApprovalRequestOptions): StatewireApprovalRequest<TValue>;

package/dist/chat-ui/header/conversation-history-panel.d.ts

@@ -23,5 +23,15 @@ export interface ConversationHistoryPanelProps {
     hasNextPage?: boolean;
     isFetchingNextPage?: boolean;
     onLoadMore?: () => void;
+    /**
+     * The pointer has rested on a conversation row for `hoverIntentDelayMs`:
+     * the user is likely to open it next. Hosts wake and pre-dial the thread
+     * here so the click lands on a warm instance with its hello in hand.
+     */
+    onHoverIntent?: (threadId: string) => void;
+    /** The pointer left a row whose intent had fired. */
+    onHoverIntentEnd?: (threadId: string) => void;
+    /** Dwell before a hover counts as intent; a pass-through never fires. */
+    hoverIntentDelayMs?: number;
 }
-export declare function ConversationHistoryPanel({ conversations, activeThreadId, search, onSearchChange, activityFilter, onActivityFilterChange, originFilter, onOriginFilterChange, onSelect, onNewChat, onRefresh, onArchive, onSetReadState, isLoading, isRefreshing, hasNextPage, isFetchingNextPage, onLoadMore, }: ConversationHistoryPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function ConversationHistoryPanel({ conversations, activeThreadId, search, onSearchChange, activityFilter, onActivityFilterChange, originFilter, onOriginFilterChange, onSelect, onNewChat, onRefresh, onArchive, onSetReadState, isLoading, isRefreshing, hasNextPage, isFetchingNextPage, onLoadMore, onHoverIntent, onHoverIntentEnd, hoverIntentDelayMs, }: ConversationHistoryPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/chat-ui/index.d.ts

@@ -11,6 +11,8 @@ export { ChatThreadShell } from "./thread/chat-thread-shell";
 export type { ChatThreadMessageComponents, ChatThreadShellProps, } from "./thread/chat-thread-shell";
 export { ChatComposerDock } from "./thread/chat-composer-dock";
 export type { ChatComposerDockProps } from "./thread/chat-composer-dock";
+export { HISTORY_EDGE_NEAR_MARGIN_PX, HistoryEdgeRow, type HistoryEdgeRowProps, StatewireHistoryEdge, type StatewireHistoryEdgeProps, THREAD_VIEWPORT_ATTR, } from "./thread/statewire-history-edge";
+export { StatewireToolOutputsContext, useStatewireToolOutputs, } from "../provider/statewire-window-context";
 export { ComposerSendOrStop } from "./thread/composer-send-or-stop";
 export type { ComposerSendOrStopComponents, ComposerSendOrStopProps, ComposerStopControls, ComposerSubmitHandle, } from "./thread/composer-send-or-stop";
 export { ChatHeader, ChatHeaderActions, ChatHeaderIdentity, ChatHeaderRoot, } from './header/chat-header';
@@ -38,4 +40,8 @@ export { TextShimmerLoader, ThreadRunningIndicator, } from "./messages/running-i
 export { SignInCard, SignInConsent, SignInFallbackSection, SignInSecondaryButton, SignInSelect, SignInTextField, } from "./auth/sign-in-card";
 export { RuntimeMessageCard, type RuntimeMessageCardProps } from "./messages/runtime-message";
 export { ContinuePill } from "./messages/continue-pill";
-export { StatewireContinueRunAffordance, StatewireContinueRunButton, type StatewireContinueRunButtonProps, StatewireRunEndedFooter, type StatewireRunEndedFooterProps, } from "./messages/statewire-continue-run";
+export { type ReadStatewireTailEnding, StatewireContinueRunAffordance, StatewireContinueRunButton, type StatewireContinueRunButtonProps, StatewireRunEndedFooter, type StatewireRunEndedFooterActionsContext, type StatewireRunEndedFooterProps, type StatewireTailEnding, } from "./messages/statewire-continue-run";
+export { StatewireApprovalCard, type StatewireApprovalCardProps, type StatewireApprovalRequestContext, } from "../chat/StatewireApprovalCard";
+export { type StatewireApprovalRequest, type StatewireInterruptPredicate, type UseStatewireApprovalRequestOptions, useStatewireApprovalRequest, } from "../chat/use-statewire-approval-request";
+export { StatewireQueuedMessages, type StatewireQueueEditorContext, type StatewireQueueEvent, type StatewireQueueRowContentContext, type StatewireQueuedMessagesProps, } from "../chat/StatewireQueuedMessages";
+export { HITL_PENDING_RESUME_GRACE_MS } from "@athenaintel/agent-runtime";

package/dist/chat-ui/mentions/suggestions/shims.d.ts

@@ -13,7 +13,3 @@ export declare const useDebugMenuStore: () => {
 export declare function Spinner({ className }: {
     className?: string;
 }): import("react/jsx-runtime").JSX.Element;
-export declare const toast: {
-    error: (msg: string) => void;
-    success: (msg: string) => void;
-};

package/dist/chat-ui/messages/runtime-message.d.ts

@@ -7,12 +7,11 @@
  * from the same {@link AthenaRuntimeMessage} so the taxonomy cannot drift.
  */
 import { type AthenaRuntimeMessage } from "@athenaintel/agent-runtime";
-import type { FC, ReactNode } from "react";
-export interface RuntimeMessageCardProps {
+import type { ComponentPropsWithoutRef, FC, ReactNode } from "react";
+export interface RuntimeMessageCardProps extends Omit<ComponentPropsWithoutRef<"div">, "children" | "role"> {
     message: AthenaRuntimeMessage;
     /** An inline affordance (e.g. a Continue button) rendered inside the card. */
     action?: ReactNode;
-    className?: string;
 }
 /**
  * The status row for a runtime ending. For `stopped` / `paused` / `failed` it

package/dist/chat-ui/messages/statewire-continue-run.d.ts

@@ -1,4 +1,6 @@
-import type { ReactElement } from "react";
+import { type ThreadMessage } from "@assistant-ui/react";
+import { type AthenaRuntimeMessageKind, type DeepAgentThreadStatus } from "@athenaintel/agent-runtime";
+import type { ReactElement, ReactNode } from "react";
 export interface StatewireContinueRunButtonProps {
     /**
      * Also offer Continue while the thread projects `ready`. An old snapshot
@@ -6,6 +8,14 @@ export interface StatewireContinueRunButtonProps {
      * continuable; the marker row that mounts this button knows that.
      */
     allowReadyFallback?: boolean;
+    /**
+     * Called as the continue dispatches (after the pill's exit animation) —
+     * the host's telemetry hook. Receives the settled status and live run id.
+     */
+    onContinue?: (context: {
+        status: DeepAgentThreadStatus;
+        runId: string | null;
+    }) => void;
 }
 /**
  * Dispatches the bare `run/continue` for the live Statewire thread — the
@@ -14,10 +24,12 @@ export interface StatewireContinueRunButtonProps {
  * optimistic running-flip (the pill unmounts once the dispatch is accepted)
  * and routes rejections to the runtime's shared `onError` policy.
  *
- * Requires `capabilities.continue` on the host thread and a statewire aui
- * scope (throws outside one, like every `useStatewire*` hook).
+ * Gated on the LIVE thread status, never on the persisted marker: markers live
+ * in the transcript forever, while continuability is a property of the
+ * current run state. Requires `capabilities.continue` on the host thread and
+ * a statewire aui scope (throws outside one, like every `useStatewire*` hook).
  */
-export declare function StatewireContinueRunButton({ allowReadyFallback, }?: StatewireContinueRunButtonProps): ReactElement | null;
+export declare function StatewireContinueRunButton({ allowReadyFallback, onContinue, }?: StatewireContinueRunButtonProps): ReactElement | null;
 /**
  * Recovery affordance for the latest persisted stopped/failed run marker,
  * for the `runtimeMessageAction` slot of `createAssistantMessage`.
@@ -27,15 +39,44 @@ export declare function StatewireContinueRunButton({ allowReadyFallback, }?: Sta
  * legacy runtimes where they would throw.
  */
 export declare function StatewireContinueRunAffordance(): ReactElement | null;
+/** The ending a transcript row paints, as the footer needs to know it. */
+export interface StatewireTailEnding {
+    kind: AthenaRuntimeMessageKind;
+    /** A send-now cancellation: kept in the data, painted as nothing. */
+    silent: boolean;
+}
+/** Reads the runtime ending (marker or handoff) a message row renders, if any. */
+export type ReadStatewireTailEnding = (message: ThreadMessage) => StatewireTailEnding | null;
+export interface StatewireRunEndedFooterActionsContext {
+    /** The live settled status the footer describes. */
+    status: "stopped" | "error";
+    /** The ending the tail row renders, when it renders one (silent markers read as none). */
+    tailEndingKind: AthenaRuntimeMessageKind | null;
+}
 export interface StatewireRunEndedFooterProps {
     /** Merged onto the recovery card's default classes. */
     className?: string;
+    /**
+     * How the host's assistant row paints the transcript tail. The default reads
+     * the runtime ending only (a persisted marker or handoff); a host whose row
+     * also styles an assistant-ui error status as a failed ending passes a
+     * reader that reports it, so the footer never doubles that row's recovery.
+     */
+    readTailEnding?: ReadStatewireTailEnding;
+    /**
+     * The recovery controls. The default renders Continue unless the tail row
+     * (a marker of another kind) already carries it; hosts with richer recovery
+     * (Retry + Continue) supply their own and decide ownership from the context.
+     */
+    renderActions?: (context: StatewireRunEndedFooterActionsContext) => ReactNode;
 }
 /**
  * Recovery row for a settled run whose persisted ending is no longer the
  * transcript tail — rendered after the messages (`renderMessages`). Rewinds,
  * compaction, and older snapshots can all leave the durable run state
- * recoverable without a marker row that owns the action. Renders nothing on
- * legacy (non-statewire) threads.
+ * recoverable without a marker row that owns the action. The failure copy
+ * comes from the replicated run error (`runs.error.message`) — the same text
+ * the marker would have carried. Renders nothing on legacy (non-statewire)
+ * threads.
  */
-export declare function StatewireRunEndedFooter({ className, }?: StatewireRunEndedFooterProps): ReactElement | null;
+export declare function StatewireRunEndedFooter({ className, readTailEnding, renderActions, }?: StatewireRunEndedFooterProps): ReactElement | null;

package/dist/chat-ui/messages/user-edit-composer.d.ts

@@ -2,7 +2,10 @@ import type { FC } from "react";
 /**
  * Rendered in place of a user message while it is being edited (entered via
  * the action bar's Edit control, which seeds this composer with the message
- * text). Sending submits the message-scoped composer, which the Statewire
- * runtime maps to a `run/edit` rewind; Escape/Cancel exits edit mode.
+ * text). Sending leaves as a `run/edit` anchored on the host's own parent of
+ * the message (`useDeepAgentMessageEditSubmit`) — on a windowed wire the
+ * lane's `anchorBefore` at the window edge — so the rewind is never rejected
+ * `wrong-anchor` the way the library's converted-message anchor is after a
+ * chunked assistant turn; Escape/Cancel exits edit mode.
  */
 export declare const UserEditComposer: FC;

package/dist/chat-ui/statewire.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The statewire chat surfaces every Athena host mounts — the HITL approval
+ * card, the queued-messages tray, the continue affordances and the run-ended
+ * footer, with the runtime-message card and Continue pill they render — as a
+ * lean entry point. Hosts that already have their own composer and mention
+ * stack (Olympus) import this instead of the full `chat-ui` barrel, so the
+ * SDK's Tiptap and mention modules never enter their build graph.
+ *
+ * Published as the `@athenaintel/react/chat-ui/statewire` sub-path.
+ */
+export { StatewireApprovalCard, type StatewireApprovalCardProps, type StatewireApprovalRequestContext, } from "../chat/StatewireApprovalCard";
+export { type StatewireApprovalRequest, type StatewireInterruptPredicate, type UseStatewireApprovalRequestOptions, useStatewireApprovalRequest, } from "../chat/use-statewire-approval-request";
+export { StatewireQueuedMessages, type StatewireQueueEditorContext, type StatewireQueueEvent, type StatewireQueueRowContentContext, type StatewireQueuedMessagesProps, } from "../chat/StatewireQueuedMessages";
+export { HistoryEdgeRow, type HistoryEdgeRowProps, StatewireHistoryEdge, type StatewireHistoryEdgeProps, } from "./thread/statewire-history-edge";
+export { StatewireToolOutputsContext, useStatewireToolOutputs, } from "../provider/statewire-window-context";
+export { ContinuePill } from "./messages/continue-pill";
+export { RuntimeMessageCard, type RuntimeMessageCardProps } from "./messages/runtime-message";
+export { type ReadStatewireTailEnding, StatewireContinueRunAffordance, StatewireContinueRunButton, type StatewireContinueRunButtonProps, StatewireRunEndedFooter, type StatewireRunEndedFooterActionsContext, type StatewireRunEndedFooterProps, type StatewireTailEnding, } from "./messages/statewire-continue-run";
+export { HITL_PENDING_RESUME_GRACE_MS } from "@athenaintel/agent-runtime";

package/dist/chat-ui/thread/chat-thread-shell.d.ts

@@ -31,6 +31,12 @@ export interface ChatThreadShellProps {
     viewportOverlay?: ReactNode;
     /** Empty-thread state, rendered via ThreadPrimitive.Empty when provided. */
     welcome?: ReactNode;
+    /**
+     * Rendered inside the message column right above the messages — the
+     * windowed wire's history edge (`StatewireHistoryEdge`): the "N earlier
+     * messages" row that pages older history in and fetches cut tool outputs.
+     */
+    beforeMessages?: ReactNode;
     /** Message renderers for ThreadPrimitive.Messages. */
     components: ChatThreadMessageComponents;
     /**
@@ -106,4 +112,4 @@ export interface ChatThreadShellProps {
  * layout, scroll behaviour, and empty/running states stay identical across
  * surfaces so fixes land once.
  */
-export declare function ChatThreadShell({ overlay, header, banners, viewportOverlay, welcome, components, renderMessages, belowViewport, composer, panelClassName, maxWidth, turnAnchor, viewportClassName, contentClassName, runningIndicator, scrollToBottom, viewportFooter, viewportFooterClassName, readOnly, }: ChatThreadShellProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatThreadShell({ overlay, header, banners, viewportOverlay, welcome, beforeMessages, components, renderMessages, belowViewport, composer, panelClassName, maxWidth, turnAnchor, viewportClassName, contentClassName, runningIndicator, scrollToBottom, viewportFooter, viewportFooterClassName, readOnly, }: ChatThreadShellProps): import("react/jsx-runtime").JSX.Element;

package/dist/chat-ui/thread/statewire-history-edge.d.ts

@@ -0,0 +1,52 @@
+import { type DeepAgentHistoryLoadEvent, type DeepAgentToolOutputStore } from "@athenaintel/agent-runtime";
+import type { FC } from "react";
+/** The attribute `ChatThreadShell` stamps on the scroll viewport. */
+export declare const THREAD_VIEWPORT_ATTR = "data-aui-thread-viewport";
+/**
+ * How far above the viewport the edge row counts as near: the row sits above
+ * the first loaded message, so reaching it means the user has scrolled past
+ * everything loaded and the next page should already be on its way.
+ */
+export declare const HISTORY_EDGE_NEAR_MARGIN_PX = 1500;
+export interface HistoryEdgeRowProps {
+    /** Messages older than the loaded window the server still holds. */
+    olderCount: number;
+    /** A page of older history is in flight. */
+    loading: boolean;
+    onLoadOlder: () => void;
+    className?: string;
+    /** The row element, for the viewport observer. */
+    rowRef?: (element: HTMLElement | null) => void;
+}
+/**
+ * The top edge of the LOADED history on a windowed wire: how many older
+ * messages the server still holds, a manual way to load the next page, and
+ * the in-flight state. Renders nothing when the whole transcript is loaded
+ * (or the wire is not windowed).
+ */
+export declare const HistoryEdgeRow: FC<HistoryEdgeRowProps>;
+export interface StatewireHistoryEdgeProps {
+    /**
+     * The thread's tool-output store (the one its converter substitutes from).
+     * Defaults to `AthenaProvider`'s; hosts mounting the runtime themselves pass
+     * the store they gave `useDeepAgentRuntime({ toolOutputs })`.
+     */
+    toolOutputs?: DeepAgentToolOutputStore;
+    className?: string;
+    /** A `history/load` settled (telemetry). */
+    onHistoryLoad?: (event: DeepAgentHistoryLoadEvent) => void;
+}
+/**
+ * The client half of the windowed wire for a DOM thread — mounted once per
+ * thread, inside the scroll viewport above the messages (`ChatThreadShell`'s
+ * `beforeMessages` slot):
+ *
+ * - renders the "N earlier messages" edge row and loads the next page when
+ *   the row comes near the viewport (scrolling up) or on its button, keeping
+ *   the reading position when the page lands above the view;
+ * - fetches cut tool outputs whole for the rendered cards, so they re-render
+ *   complete through the converter (`toolOutputs`).
+ *
+ * Inert on a wire that is not windowed: no row, no reads.
+ */
+export declare const StatewireHistoryEdge: FC<StatewireHistoryEdgeProps>;

package/dist/chat-ui-statewire.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const statewireHistoryEdge = require("./statewire-history-edge-C8uyTEjX.cjs");
+const statewireContinueRun = require("./statewire-continue-run-nE9VCKUh.cjs");
+require("./trash-2-B5OaNAL7.cjs");
+require("react");
+require("@assistant-ui/tap");
+require("statewire");
+require("@assistant-ui/react-statewire");
+require("@assistant-ui/store");
+require("@assistant-ui/core");
+exports.ContinuePill = statewireHistoryEdge.ContinuePill;
+exports.HITL_PENDING_RESUME_GRACE_MS = statewireHistoryEdge.HITL_PENDING_RESUME_GRACE_MS;
+exports.HistoryEdgeRow = statewireHistoryEdge.HistoryEdgeRow;
+exports.RuntimeMessageCard = statewireHistoryEdge.RuntimeMessageCard;
+exports.StatewireApprovalCard = statewireHistoryEdge.StatewireApprovalCard;
+exports.StatewireHistoryEdge = statewireHistoryEdge.StatewireHistoryEdge;
+exports.StatewireQueuedMessages = statewireHistoryEdge.StatewireQueuedMessages;
+exports.StatewireToolOutputsContext = statewireHistoryEdge.StatewireToolOutputsContext;
+exports.useStatewireApprovalRequest = statewireHistoryEdge.useStatewireApprovalRequest;
+exports.useStatewireToolOutputs = statewireHistoryEdge.useStatewireToolOutputs;
+exports.StatewireContinueRunAffordance = statewireContinueRun.StatewireContinueRunAffordance;
+exports.StatewireContinueRunButton = statewireContinueRun.StatewireContinueRunButton;
+exports.StatewireRunEndedFooter = statewireContinueRun.StatewireRunEndedFooter;
+//# sourceMappingURL=chat-ui-statewire.cjs.map

package/dist/chat-ui-statewire.cjs.map

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

package/dist/chat-ui-statewire.js

@@ -0,0 +1,25 @@
+import { C, H, a, R, S, b, c, d, u, e } from "./statewire-history-edge-CPohUKMt.js";
+import { S as S2, a as a2, b as b2 } from "./statewire-continue-run-D34gS7_1.js";
+import "./trash-2-CCwSURL-.js";
+import "react";
+import "@assistant-ui/tap";
+import "statewire";
+import "@assistant-ui/react-statewire";
+import "@assistant-ui/store";
+import "@assistant-ui/core";
+export {
+  C as ContinuePill,
+  H as HITL_PENDING_RESUME_GRACE_MS,
+  a as HistoryEdgeRow,
+  R as RuntimeMessageCard,
+  S as StatewireApprovalCard,
+  S2 as StatewireContinueRunAffordance,
+  a2 as StatewireContinueRunButton,
+  b as StatewireHistoryEdge,
+  c as StatewireQueuedMessages,
+  b2 as StatewireRunEndedFooter,
+  d as StatewireToolOutputsContext,
+  u as useStatewireApprovalRequest,
+  e as useStatewireToolOutputs
+};
+//# sourceMappingURL=chat-ui-statewire.js.map

package/dist/chat-ui-statewire.js.map

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