@athenaintel/react 0.17.0 → 0.19.0

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

@@ -1,35 +1,92 @@
-import type { ReasoningMessagePartComponent, TextMessagePartComponent, ToolCallMessagePartComponent } from '@assistant-ui/react';
+import type { ReasoningMessagePartComponent, TextMessagePartComponent, ThreadAssistantMessagePart, ToolCallMessagePartComponent, ToolCallMessagePartProps } from '@assistant-ui/react';
+import { type ComponentType, type ReactNode } from 'react';
+import { type ActivityPhase } from './activity-timeline';
+import { type CollapsibleGroupProps } from './CollapsibleGroup';
+import { type GroupingFunction } from './grouping-function';
 import { type GetToolGroupKey } from './toolkit-map';
+export declare function resetRememberedExpansionsForTests(): void;
 /**
- * Renders only the text emitted after the last tool-call as the assistant's
- * final response. Ported from olympus `SuperGroupingFinalText`. Hidden while
- * the message is still running — call it as a sibling of `SuperGroupingCard`
- * after the run completes.
+ * The details disclosure: remembered per expansion key, and — when the host
+ * opts in — opened once when the turn starts waiting on the person, so the
+ * approval controls inside the details are visible without a click.
  */
-export declare const SuperGroupingFinalText: import("react").MemoExoticComponent<({ TextComponent, }: {
-    TextComponent: TextMessagePartComponent;
-}) => import("react/jsx-runtime").JSX.Element | null>;
+export declare function useActivityExpansion({ expansionKey, phase, expandWhileWaiting, }: {
+    expansionKey: string;
+    phase: ActivityPhase;
+    expandWhileWaiting?: boolean;
+}): {
+    expanded: boolean;
+    toggleExpanded: () => void;
+};
 export interface SuperGroupingCardProps {
-    /** Tool UIs to render inside the details panel. */
-    toolUIs: Record<string, ToolCallMessagePartComponent>;
+    /** Tool UIs to render inside the details panel, by tool name (registered tool UIs still apply). */
+    toolUIs?: Record<string, ToolCallMessagePartComponent>;
+    /** Fallback for tools without a UI; the SDK's `ToolFallback` by default. */
+    ToolFallback?: ComponentType<ToolCallMessagePartProps>;
     /** Text renderer for the details panel. */
     TextComponent: TextMessagePartComponent;
     /** Reasoning renderer for the details panel. */
     ReasoningComponent?: ReasoningMessagePartComponent;
-    /** Override the default toolkit lookup used to drive sub-grouping. */
+    /** Per-toolkit block inside the details panel; the SDK's `CollapsibleGroup` by default. */
+    GroupComponent?: ComponentType<CollapsibleGroupProps>;
+    /** Toolkit lookup driving the per-toolkit sub-grouping; the SDK's static map by default. */
     getToolGroupKey?: GetToolGroupKey;
+    /** A complete grouping function, when the host builds its own (overrides `getToolGroupKey`). */
+    groupingFunction?: GroupingFunction;
+    /** Tools whose unresolved call means the turn is waiting on the person (see `buildActivityTimeline`). */
+    waitingTools?: ReadonlySet<string>;
+    /** Tools whose result is a relayed application payload (see `buildActivityTimeline`). */
+    passThroughTools?: ReadonlySet<string>;
+    /** Host assertion that the turn is waiting on the person (Olympus's allotment store). */
+    waitingForInput?: boolean;
+    /** Names tools the shared registry has no entry for (Olympus's tool catalog). */
+    resolveToolDisplayName?: (toolName: string) => string | undefined;
+    /** Key the disclosure choice is remembered under; the message id by default. */
+    expansionKey?: string;
+    /** Open the details once when the turn starts waiting on the person. */
+    expandWhileWaiting?: boolean;
+    /** How many latest steps the live list shows before folding the rest into "N earlier steps". */
+    maxVisibleSteps?: number;
+    /** Extra segments after the collapsed summary ("1m 23s", "12.4k tokens"), joined with " · ". */
+    summaryDetails?: readonly string[];
+    /** Header controls beside the title (a stop button while running, a changes button once done). */
+    renderHeaderActions?: (context: {
+        phase: ActivityPhase;
+        messageContent: readonly ThreadAssistantMessagePart[];
+    }) => ReactNode;
+    /** A line under the header while the turn is live (an elapsed timer). */
+    renderRunningMeta?: (context: {
+        phase: ActivityPhase;
+    }) => ReactNode;
+    className?: string;
+    classNames?: {
+        root?: string;
+        details?: string;
+    };
 }
 /**
- * Ported from `olympus/src/components/chat/sidebar/SuperGroupingCard.tsx`.
+ * The grouped ("conversational") view of an assistant turn: one "Athena is
+ * working" card while the turn runs, listing its latest steps; a collapsed
+ * "Used N tools" summary once it ends, with the full tool cards behind a
+ * details disclosure. The answer itself renders below the card
+ * (`SuperGroupingFinalText`). Shared by the SDK's `AthenaChat`, Olympus, and
+ * the Chrome extension, which supply their own text/tool renderers and the
+ * host-specific controls through the slots.
  *
- * Trimmed to drop Olympus-only deps:
- * - `useChatAllotmentStore.isWaitingForUserInput` (Olympus allotment system) — dropped.
- * - `useUserIsAdmin` admin-only details toggle — replaced with always-visible toggle.
- * - `stopActiveComposerRun` stop button — dropped; users stop from the composer.
+ * The details panel stays mounted (visually hidden) while the turn is live so
+ * the tool UIs inside run their effects — an asset-streaming card's follow
+ * mode must not wait for "Show details".
  *
- * Renders a single "Athena is working" card during execution and collapses to
- * "Used N tools" on completion. The expanded details panel uses
- * `MessagePrimitive.Unstable_PartsGrouped` (assistant-ui's legacy grouping
- * API, still exported as deprecated) with a per-toolkit `CollapsibleGroup`.
+ * Selector discipline: raw reads only (`message.content`, `message.status`,
+ * `message.id`); every derivation runs in `useMemo` — a selector that returned
+ * a fresh array would tear through `useSyncExternalStore`.
+ */
+export declare const SuperGroupingCard: import("react").MemoExoticComponent<({ toolUIs, ToolFallback: ToolFallbackComponent, TextComponent, ReasoningComponent, GroupComponent, getToolGroupKey, groupingFunction, waitingTools, passThroughTools, waitingForInput, resolveToolDisplayName, expansionKey: expansionKeyProp, expandWhileWaiting, maxVisibleSteps, summaryDetails, renderHeaderActions, renderRunningMeta, className, classNames, }: SuperGroupingCardProps) => import("react/jsx-runtime").JSX.Element | null>;
+/**
+ * The turn's visible answer, rendered below the card: the text after the last
+ * tool call (all of it when the turn called no tools), streaming while the
+ * turn is live so the person reads the answer as it arrives.
  */
-export declare const SuperGroupingCard: import("react").MemoExoticComponent<({ toolUIs, TextComponent, ReasoningComponent, getToolGroupKey, }: SuperGroupingCardProps) => import("react/jsx-runtime").JSX.Element | null>;
+export declare const SuperGroupingFinalText: import("react").MemoExoticComponent<({ TextComponent, }: {
+    TextComponent: TextMessagePartComponent;
+}) => import("react/jsx-runtime").JSX.Element | null>;

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';
@@ -36,3 +38,10 @@ export { UserEditComposer } from "./messages/user-edit-composer";
 export { MessageActionsReadOnlyProvider, useMessageActionsReadOnly, } from "./messages/message-actions-config";
 export { TextShimmerLoader, ThreadRunningIndicator, } from "./messages/running-indicator";
 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 { 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/data/api-client.d.ts

@@ -20,6 +20,30 @@ export declare function fetchGraphQL<T = any>(auth: MentionAuthContext, query: s
 export declare const SIMPLE_SEARCH_QUERY = "\n  query SimpleSearch($input: SimpleSearchRequestInput!) {\n    simpleSearch(input: $input) {\n      assets {\n        \n  id\n  title\n  athenaOriginalType\n  athenaConvertedType\n  parentFolderId\n  updatedAt\n  isFavorited\n  isArchived\n  isHidden\n\n      }\n      totalCount\n    }\n  }\n";
 export declare const PAGINATED_ASSETS_QUERY = "\n  query GetPaginatedAssetsForWorkspace(\n    $limit: Int!\n    $offset: Int!\n    $parentFolderId: String\n    $filterTypes: [String!]\n    $filterColumns: ColumnFilter\n  ) {\n    getPaginatedAssetsForWorkspace(\n      limit: $limit\n      offset: $offset\n      parentFolderId: $parentFolderId\n      filterTypes: $filterTypes\n      filterColumns: $filterColumns\n    ) {\n      \n  id\n  title\n  athenaOriginalType\n  athenaConvertedType\n  parentFolderId\n  updatedAt\n  isFavorited\n  isArchived\n  isHidden\n\n    }\n  }\n";
 export declare const WORKSPACE_MEMBERS_QUERY = "\n  query GetUsersInWorkspace($workspaceId: String!) {\n    getUsersInWorkspace(workspaceId: $workspaceId) {\n      id\n      email\n      firstName\n      lastName\n      isAdmin\n      avatarUrl\n    }\n  }\n";
+export declare const TOOL_CATALOG_QUERY = "\n  query MentionToolCatalog {\n    getToolkitToToolsMapping {\n      tools {\n        id\n        name\n        description\n        icon\n        adminOnly\n        isMentionable\n      }\n      toolkits {\n        name\n        displayName\n        description\n        icon\n        onlyAdmin\n        hideFromMenu\n        isMentionable\n      }\n    }\n  }\n";
+export interface ToolCatalogTool {
+    id: string;
+    name: string;
+    description: string | null;
+    icon: string;
+    adminOnly: boolean;
+    isMentionable: boolean;
+}
+export interface ToolCatalogToolkit {
+    name: string;
+    displayName: string;
+    description: string;
+    icon: string;
+    onlyAdmin: boolean;
+    hideFromMenu: boolean;
+    isMentionable: boolean;
+}
+export interface ToolCatalogResult {
+    getToolkitToToolsMapping: {
+        tools: ToolCatalogTool[];
+        toolkits: ToolCatalogToolkit[];
+    };
+}
 export interface AssetResult {
     id: string;
     title: string | null;

package/dist/chat-ui/mentions/suggestions/data/sources/index.d.ts

@@ -49,6 +49,11 @@ export interface TeamConfig {
     auth: MentionAuthContext;
 }
 export declare const fetchTeam: SourceFn<TeamConfig>;
+export interface ToolCatalogConfig {
+    auth: MentionAuthContext;
+}
+export declare const fetchTools: SourceFn<ToolCatalogConfig>;
+export declare const fetchToolkits: SourceFn<ToolCatalogConfig>;
 export interface DrivesConfig {
     auth: MentionAuthContext;
 }

package/dist/chat-ui/mentions/suggestions/data/use-mention-suggestions.d.ts

@@ -21,7 +21,7 @@ export type MentionSuggestionsStore = Store<MentionSuggestionsStoreState>;
 /**
  * All mention menu categories, in display order.
  */
-export declare const ROOT_MENTION_CATEGORIES: readonly ["favorites", "assets", "projects", "browse_profiles", "folders", "team", "drives"];
+export declare const ROOT_MENTION_CATEGORIES: readonly ["favorites", "assets", "projects", "browse_profiles", "folders", "tools", "toolkits", "team", "drives"];
 export type MentionRootCategory = (typeof ROOT_MENTION_CATEGORIES)[number];
 /**
  * Creates a stable MentionSuggestionsStore.

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/continue-pill.d.ts

@@ -0,0 +1,13 @@
+import { type FC } from "react";
+/**
+ * Shared Continue action for recoverable chat states.
+ *
+ * The dispatch waits for the exit animation to paint. If the owning runtime
+ * does not leave the recoverable state (for example, the command is rejected),
+ * the control resets so the user can try again.
+ */
+export declare const ContinuePill: FC<{
+    onClick: () => void;
+    ariaLabel: string;
+    dataTestId?: string;
+}>;

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

@@ -1,6 +1,6 @@
 import { type ToolCallMessagePartComponent } from "@assistant-ui/react";
 import "@assistant-ui/react-markdown/styles/dot.css";
-import type { ButtonHTMLAttributes, FC, ReactNode } from "react";
+import { type ButtonHTMLAttributes, type FC, type ReactNode } from "react";
 import type { ComposerAction } from "../composer/composer-action";
 export declare function IconButton({ children, tooltip, className, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
     tooltip: string;
@@ -22,12 +22,17 @@ export interface CreateAssistantMessageOptions {
      * timelines supply their own; the default renders markdown and tool cards.
      */
     content?: FC;
+    /**
+     * Inline affordance rendered inside a runtime-ending card (e.g. a Continue
+     * button). Hosts without one leave it unset.
+     */
+    runtimeMessageAction?: ReactNode;
 }
 /**
  * Builds the assistant bubble. Call this once per host (memoized on its
  * inputs) so the returned component identity stays stable across renders.
  */
-export declare function createAssistantMessage({ toolFallback, extraActions, content: Content, }: CreateAssistantMessageOptions): FC;
+export declare function createAssistantMessage({ toolFallback, extraActions, content: Content, runtimeMessageAction, }: CreateAssistantMessageOptions): FC;
 /** Panel chrome: the thread card and the header row that sits inside it. */
 export declare const THREAD_PANEL_CLASS = "m-1 flex min-h-0 flex-1 flex-col overflow-hidden rounded-[18px] border border-dashed border-amber-500 bg-background shadow-[0_1px_10px_rgba(54,45,33,0.08)]";
 export declare const THREAD_HEADER_CLASS = "flex items-center justify-between gap-2 px-3 py-2";

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

@@ -0,0 +1,21 @@
+/**
+ * Shared DOM rendering for a runtime ending (see
+ * `@athenaintel/agent-runtime`'s `runtime-messages.ts`): the status row for a
+ * stop / pause / failure, and the banner that frames a handoff summary. Hosts
+ * that build their assistant row with `createAssistantMessage` get these for
+ * free; hosts with their own row (Olympus, mobile) render their own presenter
+ * from the same {@link AthenaRuntimeMessage} so the taxonomy cannot drift.
+ */
+import { type AthenaRuntimeMessage } from "@athenaintel/agent-runtime";
+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;
+}
+/**
+ * The status row for a runtime ending. For `stopped` / `paused` / `failed` it
+ * replaces the assistant bubble; for `handoff` it sits above the closing
+ * summary, which keeps rendering as ordinary prose.
+ */
+export declare const RuntimeMessageCard: FC<RuntimeMessageCardProps>;

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

@@ -0,0 +1,82 @@
+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
+     * can report a resting thread whose last persisted ending is still
+     * 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
+ * heal-then-continue recovery for stopped, errored, and pod-drained runs. The
+ * command is exactly what the library's `onResume` emits, so it inherits the
+ * optimistic running-flip (the pill unmounts once the dispatch is accepted)
+ * and routes rejections to the runtime's shared `onError` policy.
+ *
+ * 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, onContinue, }?: StatewireContinueRunButtonProps): ReactElement | null;
+/**
+ * Recovery affordance for the latest persisted stopped/failed run marker,
+ * for the `runtimeMessageAction` slot of `createAssistantMessage`.
+ *
+ * Marker messages remain in history forever, so only the current last message
+ * may continue. The extras guard keeps Statewire hooks out of read-only or
+ * 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. 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, 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-composer-dock.d.ts

@@ -23,7 +23,7 @@ export interface ChatComposerDockProps {
     editor: ReactNode;
     /** Toolbar contents before the spacer (attach buttons, pickers). */
     toolbarStart?: ReactNode;
-    /** Toolbar contents after the spacer (voice, capture, send/stop). */
+    /** Toolbar contents after the spacer (voice and send/stop controls). */
     toolbarEnd: ReactNode;
 }
 /**