@athenaintel/react 0.10.33 → 0.10.35

package/README.md

@@ -142,6 +142,33 @@ function App() {
 
 Set `linkClicks={{ interceptAthenaCitations: false }}` to keep Athena citation links opening in the browser while still letting your app observe all link clicks.
 
+## Standalone Asset Embeds
+
+Use `AthenaAssetEmbed` to render a native Athena asset without chat, thread history, tabs, or the SDK split-pane layout. Full mode supports documents, spreadsheets, and presentations.
+
+```tsx
+import { AthenaAssetEmbed, AthenaProvider } from '@athenaintel/react';
+
+function AssetView() {
+  return (
+    <AthenaProvider config={{ token: accessToken }}>
+      <div style={{ height: 800 }}>
+        <AthenaAssetEmbed
+          assetId="asset_123"
+          displayMode="full"
+          readOnly
+          onCitationClick={({ reference, sourceAssetId }) => {
+            console.log('Citation clicked', { reference, sourceAssetId });
+          }}
+        />
+      </div>
+    </AthenaProvider>
+  );
+}
+```
+
+When `onCitationClick` is provided, citation navigation is delegated to the host by default. Set `citationBehavior="browser"` to observe the event while preserving Athena's default new-tab navigation, or `citationBehavior="host"` to delegate navigation without providing a callback.
+
 ## Theming
 
 ```tsx

package/dist/assets/AssetPanel.d.ts

@@ -0,0 +1,6 @@
+import { type FC } from "react";
+export interface AssetPanelProps {
+    /** Register this panel as an asset-panel host when used outside AthenaLayout. */
+    manageAssetPanelHostRegistration?: boolean;
+}
+export declare const AssetPanel: FC<AssetPanelProps>;

package/dist/assets/AthenaAssetEmbed.d.ts

@@ -0,0 +1,17 @@
+import { type FC, type IframeHTMLAttributes } from "react";
+import { type AthenaAssetCitationBehavior, type AthenaAssetCitationClickEvent } from "./asset-embed-messages";
+export interface AthenaAssetEmbedProps extends Omit<IframeHTMLAttributes<HTMLIFrameElement>, "src" | "onError" | "onLoad"> {
+    assetId: string;
+    /** Defaults to the native full asset experience. */
+    displayMode?: "minimal" | "full";
+    /** Defaults to true. */
+    readOnly?: boolean;
+    expiresInSeconds?: number;
+    citationBehavior?: AthenaAssetCitationBehavior;
+    onCitationClick?: (event: AthenaAssetCitationClickEvent) => void;
+    onLoad?: () => void;
+    onError?: (error: Error) => void;
+    loadingFallback?: React.ReactNode;
+    errorFallback?: React.ReactNode | ((error: Error) => React.ReactNode);
+}
+export declare const AthenaAssetEmbed: FC<AthenaAssetEmbedProps>;

package/dist/assets/AthenaLayout.d.ts

@@ -0,0 +1,13 @@
+import { type FC, type ReactNode } from "react";
+export interface AthenaLayoutProps {
+    children: ReactNode;
+    /** Default width (%) of the chat panel when assets are open. Defaults to 50. */
+    defaultChatPercent?: number;
+    /** Minimum width (%) of each panel. Defaults to 25. */
+    minPercent?: number;
+}
+/**
+ * Layout that places the chat on the left and the asset panel on the right.
+ * When no assets are open, the chat takes full width. Includes a draggable resize handle.
+ */
+export declare const AthenaLayout: FC<AthenaLayoutProps>;

package/dist/assets/asset-embed-messages.d.ts

@@ -0,0 +1,27 @@
+export declare const ATHENA_ASSET_EMBED_READY_MESSAGE: "athena:asset-embed-ready";
+export declare const ATHENA_ASSET_EMBED_CONFIG_MESSAGE: "athena:asset-embed-config";
+export declare const ATHENA_ASSET_CITATION_CLICK_MESSAGE: "athena:asset-citation-click";
+export type AthenaAssetCitationBehavior = "browser" | "host";
+export interface AthenaAssetCitationReference {
+    id: string;
+    anchor?: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface AthenaAssetCitationClickEvent {
+    type: typeof ATHENA_ASSET_CITATION_CLICK_MESSAGE;
+    version: 1;
+    sourceAssetId?: string;
+    reference: AthenaAssetCitationReference;
+}
+export interface AthenaAssetEmbedReadyEvent {
+    type: typeof ATHENA_ASSET_EMBED_READY_MESSAGE;
+    version: 1;
+}
+export interface AthenaAssetEmbedConfigEvent {
+    type: typeof ATHENA_ASSET_EMBED_CONFIG_MESSAGE;
+    version: 1;
+    token?: string;
+    citationBehavior: AthenaAssetCitationBehavior;
+}
+export declare function isAthenaAssetEmbedReadyEvent(value: unknown): value is AthenaAssetEmbedReadyEvent;
+export declare function isAthenaAssetCitationClickEvent(value: unknown): value is AthenaAssetCitationClickEvent;

package/dist/assets/asset-panel-store.d.ts

@@ -0,0 +1,65 @@
+export type AssetType = 'presentation' | 'spreadsheet' | 'document' | 'notebook' | 'unknown';
+export type ViewMode = 'tabs' | 'tiled';
+export interface AssetTab {
+    id: string;
+    name: string | null;
+    type: AssetType;
+    slideNumber?: number;
+}
+interface ThreadAssetState {
+    tabs: AssetTab[];
+    activeTabId: string | null;
+    isOpen: boolean;
+}
+export interface AssetPanelState {
+    isOpen: boolean;
+    tabs: AssetTab[];
+    activeTabId: string | null;
+    viewMode: ViewMode;
+    isFullscreen: boolean;
+    /** The current thread ID. Asset panel state is scoped per thread. */
+    currentThreadId: string | null;
+    /** Per-thread asset panel state — tabs and active tab persist per thread. */
+    threadStates: Record<string, ThreadAssetState>;
+    /** Number of registered hosts that can reveal the asset panel. */
+    assetPanelHostCount: number;
+    /** Generation counter for auto-open tracking — incremented on reset */
+    autoOpenGeneration: number;
+    /** Tracks which assets have been auto-opened in the current generation */
+    autoOpenedAssets: Map<string, number>;
+    registerAssetPanelHost: () => void;
+    unregisterAssetPanelHost: () => void;
+    openAsset: (assetId: string, meta?: {
+        name?: string;
+        type?: AssetType;
+        slideNumber?: number;
+    }) => void;
+    closeTab: (assetId: string) => void;
+    setActiveTab: (assetId: string) => void;
+    setViewMode: (mode: ViewMode) => void;
+    closePanel: () => void;
+    toggleFullscreen: () => void;
+    /**
+     * Switch the active thread. Saves the current thread's asset panel state
+     * and restores the new thread's state (if any). Pass null to clear.
+     */
+    setCurrentThread: (threadId: string | null) => void;
+    /** Reset auto-open tracking (increments generation so new assets can auto-open) */
+    resetAutoOpen: () => void;
+    /** Check if an asset should auto-open, and mark it as opened if so */
+    markAutoOpened: (assetId: string) => boolean;
+}
+export declare const useAssetPanelStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<AssetPanelState>, "persist" | "setState"> & {
+    setState(partial: AssetPanelState | Partial<AssetPanelState> | ((state: AssetPanelState) => AssetPanelState | Partial<AssetPanelState>), replace?: false | undefined): unknown;
+    setState(state: AssetPanelState | ((state: AssetPanelState) => AssetPanelState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<AssetPanelState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AssetPanelState) => void) => () => void;
+        onFinishHydration: (fn: (state: AssetPanelState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<AssetPanelState, unknown, unknown>>;
+    };
+}>;
+export {};

package/dist/assets/asset-panel-url.d.ts

@@ -0,0 +1,17 @@
+import type { AssetType } from "./asset-panel-store";
+export interface PresentationNavigationMessage {
+    type: "NAVIGATE_TO_SLIDE";
+    assetId: string;
+    deckId: string;
+    slideNumber: number;
+}
+export declare function buildAssetIframeSrc({ embedUrl, assetType, slideNumber, }: {
+    embedUrl: string;
+    assetType: AssetType;
+    slideNumber?: number;
+}): string;
+export declare function buildPresentationNavigationMessage({ assetId, assetType, slideNumber, }: {
+    assetId: string;
+    assetType: AssetType;
+    slideNumber?: number;
+}): PresentationNavigationMessage | null;

package/dist/assets/use-asset-embed.d.ts

@@ -0,0 +1,45 @@
+export interface UseAssetEmbedOptions {
+    readOnly?: boolean;
+    expiresInSeconds?: number;
+    /** Native Olympus surface rendered by the iframe. Defaults to `minimal`. */
+    displayMode?: 'minimal' | 'full';
+}
+export interface UseAssetEmbedResult {
+    embedUrl: string | null;
+    isLoading: boolean;
+    error: string | null;
+}
+export declare function buildAssetEmbedRequestBody({ assetId, readOnly, expiresInSeconds, displayMode, }: {
+    assetId: string;
+    readOnly: boolean;
+    expiresInSeconds: number;
+    displayMode: 'minimal' | 'full';
+}): {
+    asset_id: string;
+    read_only: boolean;
+    expires_in_seconds: number;
+    display_mode: "full" | "minimal";
+};
+export declare function resolveAssetEmbedUrl({ embedUrl, appUrl, backendUrl, currentOrigin, }: {
+    embedUrl: string;
+    appUrl?: string;
+    backendUrl?: string | null;
+    currentOrigin?: string | null;
+}): string;
+/**
+ * Hook to generate an embed URL for rendering an asset in an iframe.
+ * Calls the Athena embed token endpoint.
+ *
+ * Note: The auth token is read via a ref and is intentionally NOT part
+ * of the effect dependency array. PropelAuth and similar providers refresh
+ * the token value periodically (e.g. on window focus), but the underlying
+ * session is the same — re-running the effect on every token rotation
+ * would force the iframe to reload unnecessarily. The effect only re-runs
+ * when the auth _mode_ changes (auth vs anonymous) or the asset changes.
+ */
+export declare function useAssetEmbed(assetId: string | null, options?: UseAssetEmbedOptions & {
+    backendUrl: string;
+    appUrl?: string;
+    apiKey?: string;
+    token?: string | null;
+}): UseAssetEmbedResult;

package/dist/auth/AthenaAuthContext.d.ts

@@ -0,0 +1,26 @@
+import type { AthenaAuthState } from './types';
+/**
+ * Internal context used by `AthenaAuthProvider` to share auth state.
+ * Consumed by `useAthenaAuth()` and automatically by `AthenaProvider`.
+ */
+export declare const AthenaAuthContext: import("react").Context<AthenaAuthState | null>;
+/**
+ * Read the current Athena auth state.
+ *
+ * Must be used inside an `<AthenaAuthProvider>`.
+ *
+ * @example
+ * ```tsx
+ * function UserMenu() {
+ *   const { user, isLoggedIn, logout } = useAthenaAuth();
+ *   if (!isLoggedIn) return null;
+ *   return (
+ *     <div>
+ *       <span>{user?.email}</span>
+ *       <button onClick={() => logout()}>Log out</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useAthenaAuth(): AthenaAuthState;

package/dist/auth/AthenaAuthProvider.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+export interface AthenaAuthProviderProps {
+    children: ReactNode;
+    /**
+     * Your PropelAuth auth URL (e.g. `https://auth.yourdomain.com`).
+     * Found in the PropelAuth dashboard under Frontend Integration.
+     */
+    authUrl: string;
+    /**
+     * Where to redirect after a successful login.
+     * Defaults to the current page URL.
+     */
+    postLoginRedirectUrl?: string;
+    /**
+     * Custom element displayed while the auth state is loading.
+     * Defaults to `null` (renders nothing).
+     */
+    displayWhileLoading?: ReactNode;
+}
+/**
+ * Wraps your app with Athena authentication powered by PropelAuth.
+ *
+ * Place this **above** `<AthenaProvider>` in the component tree.
+ * When present, `AthenaProvider` will automatically use the access token
+ * from this provider — no need to pass `token` or `apiKey` manually.
+ *
+ * @example
+ * ```tsx
+ * import { AthenaAuthProvider } from '@athenaintel/react/auth';
+ * import { AthenaProvider, AthenaChat } from '@athenaintel/react';
+ *
+ * function App() {
+ *   return (
+ *     <AthenaAuthProvider authUrl="https://auth.yourdomain.com">
+ *       <AthenaProvider>
+ *         <AthenaChat />
+ *       </AthenaProvider>
+ *     </AthenaAuthProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function AthenaAuthProvider({ children, authUrl, postLoginRedirectUrl, displayWhileLoading, }: AthenaAuthProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/auth/AthenaSSOProvider.d.ts

@@ -0,0 +1,91 @@
+import type { ReactNode } from 'react';
+export interface AthenaSSOProviderProps {
+    children: ReactNode;
+    /**
+     * Base URL used to resolve the Athena SSO endpoints.
+     *
+     * When omitted, the provider defaults to same-origin relative paths:
+     * `/api/sso/userinfo`, `/api/sso/initiate`, and `/api/sso/logout`.
+     *
+     * Use this when your frontend and backend live on different origins
+     * (for example `https://app.example.com` + `https://api.example.com`).
+     */
+    ssoBaseUrl?: string;
+    /**
+     * Optional override for the SSO user-info endpoint that returns the
+     * authenticated user's data and access token.
+     *
+     * The endpoint must return JSON matching `AthenaSSOUserInfo`:
+     * ```json
+     * {
+     *   "user": { "user_id": "…", "email": "…", … },
+     *   "orgMemberInfos": [{ "orgId": "…", "orgName": "…", "urlSafeOrgName": "…" }],
+     *   "accessToken": "…"
+     * }
+     * ```
+     *
+     * The request is sent with `credentials: 'include'` so that
+     * session cookies are forwarded automatically.
+     */
+    ssoUserInfoUrl?: string;
+    /**
+     * Optional override for the URL to redirect the user to when no valid
+     * SSO session exists.
+     * This is typically the SSO initiation endpoint on your backend
+     * (e.g. `https://api.yourdomain.com/api/sso/initiate`).
+     */
+    ssoLoginUrl?: string;
+    /**
+     * Optional override for the backend SSO logout endpoint.
+     * Defaults to `/api/sso/logout` (or `${ssoBaseUrl}/api/sso/logout`).
+     */
+    ssoLogoutUrl?: string;
+    /**
+     * Custom element displayed while the SSO session is being verified.
+     * Defaults to `null` (renders nothing).
+     */
+    displayWhileLoading?: ReactNode;
+    /**
+     * Custom element displayed when SSO authentication fails.
+     * If not provided, the user is automatically redirected to `ssoLoginUrl`.
+     */
+    displayOnError?: ReactNode;
+    /**
+     * Re-validate the SSO session when the window regains focus.
+     * Disabled by default. When enabled, token expiry and user switching
+     * are picked up without requiring a full page reload.
+     */
+    revalidateOnWindowFocus?: boolean;
+}
+/**
+ * Wraps your app with Athena authentication powered by an external SSO
+ * identity provider (e.g. Microsoft Entra / Azure AD, Okta, etc.).
+ *
+ * The SSO login flow is handled entirely by your backend. This provider
+ * verifies the session by fetching `ssoUserInfoUrl` and exposes the
+ * same `AthenaAuthState` context that `AthenaAuthProvider` (PropelAuth)
+ * provides, so downstream components like `<AthenaProvider>` and
+ * `useAthenaAuth()` work identically.
+ *
+ * Place this **above** `<AthenaProvider>` in the component tree.
+ *
+ * @example
+ * ```tsx
+ * import { AthenaSSOProvider } from '@athenaintel/react/auth';
+ * import { AthenaProvider, AthenaChat } from '@athenaintel/react';
+ *
+ * function App() {
+ *   return (
+ *     <AthenaSSOProvider
+ *       ssoUserInfoUrl="https://api.yourdomain.com/api/sso/userinfo"
+ *       ssoLoginUrl="https://api.yourdomain.com/api/sso/initiate"
+ *     >
+ *       <AthenaProvider>
+ *         <AthenaChat />
+ *       </AthenaProvider>
+ *     </AthenaSSOProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function AthenaSSOProvider({ children, ssoBaseUrl, ssoUserInfoUrl, ssoLoginUrl, ssoLogoutUrl, displayWhileLoading, displayOnError, revalidateOnWindowFocus, }: AthenaSSOProviderProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/auth/index.d.ts

@@ -0,0 +1,7 @@
+export { AthenaAuthProvider } from './AthenaAuthProvider';
+export type { AthenaAuthProviderProps } from './AthenaAuthProvider';
+export { AthenaSSOProvider } from './AthenaSSOProvider';
+export type { AthenaSSOProviderProps } from './AthenaSSOProvider';
+export { useAthenaAuth } from './AthenaAuthContext';
+export { AthenaAuthContext } from './AthenaAuthContext';
+export type { AthenaAuthState, AthenaUser, AthenaOrg, AthenaSSOUserInfo, AthenaSSOUserData, AthenaSSOOrgInfo, } from './types';

package/dist/auth/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Athena user information — a simplified, PropelAuth-agnostic representation.
+ */
+export interface AthenaUser {
+    userId: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    username?: string;
+    pictureUrl?: string;
+    properties?: Record<string, unknown>;
+}
+/**
+ * Athena organization membership.
+ */
+export interface AthenaOrg {
+    orgId: string;
+    orgName: string;
+    urlSafeOrgName: string;
+}
+/**
+ * User data returned by the Athena SSO `/api/sso/userinfo` endpoint.
+ * Field names use snake_case to match the backend response format.
+ */
+export interface AthenaSSOUserData {
+    user_id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    username: string;
+    picture_url: string;
+    properties: Record<string, unknown>;
+}
+/**
+ * Organization membership returned by the SSO endpoint.
+ */
+export interface AthenaSSOOrgInfo {
+    orgId: string;
+    orgName: string;
+    urlSafeOrgName: string;
+}
+/**
+ * Full response from the Athena SSO `/api/sso/userinfo` endpoint.
+ */
+export interface AthenaSSOUserInfo {
+    user: AthenaSSOUserData;
+    orgMemberInfos: AthenaSSOOrgInfo[];
+    accessToken: string;
+}
+/**
+ * Auth state exposed by `useAthenaAuth()`.
+ */
+export interface AthenaAuthState {
+    /** Whether the user is currently logged in. */
+    isLoggedIn: boolean;
+    /** Whether the auth state is still loading. */
+    isLoading: boolean;
+    /** The authenticated user, or `null` when not logged in. */
+    user: AthenaUser | null;
+    /** The current access token, or `null` when not logged in. */
+    accessToken: string | null;
+    /** Organizations the user belongs to. */
+    orgs: AthenaOrg[];
+    /** Log the user out. Redirects to the login page by default. */
+    logout: (redirectOnLogout?: boolean) => Promise<void>;
+}

package/dist/chat/AthenaChat.d.ts

@@ -0,0 +1,64 @@
+import type { EmptyMessagePartComponent, ReasoningMessagePartProps, ReasoningMessagePartComponent, TextMessagePartComponent, ToolCallMessagePartComponent } from '@assistant-ui/react';
+import { type FC } from 'react';
+import type { MentionTool } from '../mentions/use-mention-suggestions';
+export interface WelcomeSuggestion {
+    icon: React.ElementType;
+    title: string;
+    prompt: string;
+}
+export interface AthenaChatProps {
+    /** CSS class name for the root element. */
+    className?: string;
+    /** Welcome heading text. Defaults to "Hello there!" */
+    welcomeMessage?: string;
+    /** Welcome subheading text. */
+    welcomeSubtext?: string;
+    /** Maximum width for the thread content. Defaults to "44rem". */
+    maxWidth?: string;
+    /** Additional tool UIs to register by name. */
+    toolUIs?: Record<string, ToolCallMessagePartComponent>;
+    /** Mention tools available in the composer. */
+    mentionTools?: MentionTool[];
+    /** Suggestion cards shown on the welcome screen. Pass `[]` to hide.
+     *  For workflow launchers outside AthenaChat, use `useSendMessage()`.
+     */
+    welcomeSuggestions?: WelcomeSuggestion[];
+    /** Optional component overrides for message containers and key message parts. */
+    components?: AthenaChatComponents;
+    /** Collapse adjacent tool calls into a single expandable group. Defaults to `false`. */
+    groupToolCalls?: boolean;
+}
+export interface AthenaChatMessagePartComponents {
+    Text?: TextMessagePartComponent;
+    Reasoning?: ReasoningMessagePartComponent;
+    Empty?: EmptyMessagePartComponent;
+}
+export interface AthenaChatComponents {
+    UserMessage?: FC;
+    AssistantMessage?: FC;
+    AssistantActionBar?: FC<AthenaAssistantActionBarProps>;
+    messageParts?: AthenaChatMessagePartComponents;
+}
+export interface AthenaUserMessageProps {
+    TextComponent?: TextMessagePartComponent;
+}
+export interface AthenaAssistantActionBarProps {
+    className?: string;
+}
+export interface AthenaAssistantMessageProps {
+    toolUIs: Record<string, ToolCallMessagePartComponent>;
+    TextComponent?: TextMessagePartComponent;
+    ReasoningComponent?: ReasoningMessagePartComponent;
+    EmptyComponent?: EmptyMessagePartComponent;
+    ActionBarComponent?: FC<AthenaAssistantActionBarProps>;
+    /** Collapse adjacent tool calls into a single expandable group. Defaults to `false`. */
+    groupToolCalls?: boolean;
+}
+export interface AthenaReasoningPartProps extends ReasoningMessagePartProps {
+    TextComponent?: TextMessagePartComponent;
+}
+export declare const AthenaChat: FC<AthenaChatProps>;
+export declare const AthenaReasoningPart: FC<AthenaReasoningPartProps>;
+export declare const AthenaAssistantMessage: FC<AthenaAssistantMessageProps>;
+export declare const AthenaAssistantActionBar: FC<AthenaAssistantActionBarProps>;
+export declare const AthenaUserMessage: FC<AthenaUserMessageProps>;

package/dist/chat/ComposerEditorContext.d.ts

@@ -0,0 +1,30 @@
+import { type MutableRefObject, type ReactNode } from 'react';
+/**
+ * Exposes a ref to the TipTap editor instance so components outside the
+ * composer (e.g. the quote-aware send button) can read the editor content
+ * and clear it after sending.
+ */
+interface EditorHandle {
+    /** Get the current editor content as markdown. */
+    getMarkdown: () => string;
+    /** Clear the editor content. */
+    clear: () => void;
+    /** Whether the editor is empty. */
+    isEmpty: () => boolean;
+    /** Insert text at the end of the editor. */
+    insertText: (text: string) => void;
+}
+type EditorRef = MutableRefObject<EditorHandle | null>;
+interface EditorContextValue {
+    editorRef: EditorRef;
+    editorEmpty: boolean;
+    setEditorEmpty: (empty: boolean) => void;
+}
+export declare const EditorCtx: import("react").Context<EditorContextValue | null>;
+export declare function ComposerEditorProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useComposerEditorRef(): EditorRef;
+export declare function useComposerEditorEmpty(): boolean;
+export declare function useSetComposerEditorEmpty(): (empty: boolean) => void;
+export {};

package/dist/chat/athena-citation-links.d.ts

@@ -0,0 +1,18 @@
+import { type AssetType } from '../assets/asset-panel-store';
+import type { AthenaCitationLinkHandler, AthenaLinkClickHandler } from '../provider/citation-links';
+export interface ParsedAthenaCitationLink {
+    url: URL;
+    assetId: string;
+    assetIds: string[];
+    assetType: AssetType | null;
+}
+export declare const parseAthenaCitationLink: ({ href, appUrl, }: {
+    href: string;
+    appUrl?: string | null;
+}) => ParsedAthenaCitationLink | null;
+export declare const isAthenaCitationUrl: ({ href, appUrl, }: {
+    href: string;
+    appUrl?: string | null;
+}) => boolean;
+export declare const useAthenaLinkClickHandler: () => AthenaLinkClickHandler;
+export declare const useAthenaCitationLinkHandler: () => AthenaCitationLinkHandler;

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

@@ -0,0 +1,15 @@
+import type { PropsWithChildren } from 'react';
+export type CollapsibleGroupProps = PropsWithChildren<{
+    /** Group key from the grouping function (toolkit display name). */
+    groupKey?: string;
+    /** Indices of the parts belonging to this group. */
+    indices: number[];
+}>;
+/**
+ * Per-toolkit collapsible block used inside the SuperGroupingCard details
+ * panel. Ported from `olympus/src/components/CollapsibleGroup.tsx`. The
+ * Olympus version also gates "auto-stay-open" on unsubmitted email/calendar
+ * drafts (`useMessageMetadata` + `EMAIL_TOOLKIT_GROUP`); the SDK doesn't have
+ * those metadata fields, so that branch is dropped.
+ */
+export declare const CollapsibleGroup: ({ groupKey, indices, children }: CollapsibleGroupProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,35 @@
+import type { ReasoningMessagePartComponent, TextMessagePartComponent, ToolCallMessagePartComponent } from '@assistant-ui/react';
+import { type GetToolGroupKey } from './toolkit-map';
+/**
+ * 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.
+ */
+export declare const SuperGroupingFinalText: import("react").MemoExoticComponent<({ TextComponent, }: {
+    TextComponent: TextMessagePartComponent;
+}) => import("react/jsx-runtime").JSX.Element | null>;
+export interface SuperGroupingCardProps {
+    /** Tool UIs to render inside the details panel. */
+    toolUIs: Record<string, ToolCallMessagePartComponent>;
+    /** 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. */
+    getToolGroupKey?: GetToolGroupKey;
+}
+/**
+ * Ported from `olympus/src/components/copilotkit/sidebar/SuperGroupingCard.tsx`.
+ *
+ * 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.
+ *
+ * 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`.
+ */
+export declare const SuperGroupingCard: import("react").MemoExoticComponent<({ toolUIs, TextComponent, ReasoningComponent, getToolGroupKey, }: SuperGroupingCardProps) => import("react/jsx-runtime").JSX.Element | null>;

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

@@ -0,0 +1,19 @@
+import type { GetToolGroupKey } from './toolkit-map';
+type AnyPart = {
+    type: string;
+    toolName?: string;
+};
+type MessagePartGroup = {
+    groupKey: string | undefined;
+    indices: number[];
+};
+/**
+ * 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.
+ */
+export declare const createToolBasedGroupingFunction: (getToolGroupKey: GetToolGroupKey) => (parts: readonly AnyPart[]) => MessagePartGroup[];
+export {};

package/dist/chat/super-grouping/tool-status-labels.d.ts

@@ -0,0 +1 @@
+export declare function getToolStatusLabel(toolName: string, status: 'running' | 'complete' | 'error' | 'incomplete' | undefined): string;