@athenaintel/react 0.13.0 → 0.14.0

package/dist/chat-ui/mentions/suggestions/data/scope-registry.d.ts

@@ -0,0 +1,105 @@
+import { type ItemCache } from './item-cache';
+import type { FetchState, MenuScope, SourceFn } from './types';
+/**
+ * Scope Registry
+ *
+ * Plain object + pure functions for managing source functions.
+ * Each scope has a source function, config, and fetch state per query.
+ */
+/**
+ * Scope registry entry - per menu scope
+ * Stores source function, config, and fetch state per query
+ */
+export interface ScopeRegistryEntry {
+    scope: MenuScope;
+    sourceFn: SourceFn;
+    sourceConfig: any;
+    fetchStates: Record<string, FetchState>;
+    isFlat?: boolean;
+}
+/**
+ * Scope registry - plain object
+ * Maps MenuScope → ScopeRegistryEntry
+ */
+export interface ScopeRegistry {
+    entries: Record<MenuScope, ScopeRegistryEntry>;
+    scopeBindings: Map<MenuScope, MenuScope>;
+}
+/**
+ * Create empty registry
+ */
+export declare function createScopeRegistry(): ScopeRegistry;
+/**
+ * Register a source function for a specific scope
+ * Creates full entry immediately with empty fetchStates
+ *
+ * @param registry - Registry to mutate
+ * @param scope - Scope identifier
+ * @param sourceFn - Pure function to fetch/transform items
+ * @param sourceConfig - Any configuration the source function needs (can include getters!)
+ * @param isFlat - If true, items won't get navigatesToScope (flat list, no hierarchy)
+ */
+export declare function registerSource(registry: ScopeRegistry, scope: MenuScope, sourceFn: SourceFn, sourceConfig?: any, isFlat?: boolean): void;
+/**
+ * Unregister a source (cleanup)
+ */
+export declare function unregisterSource(registry: ScopeRegistry, scope: MenuScope): void;
+/**
+ * Get or create entry for scope
+ * Auto-inherits source function from parent if not explicitly registered
+ *
+ * @param registry - Registry to read/mutate
+ * @param scope - Scope to get entry for
+ * @param parentScope - Optional parent scope (for inheritance)
+ * @returns Entry (may be newly created)
+ */
+export declare function getEntry(registry: ScopeRegistry, scope: MenuScope, parentScope?: MenuScope): ScopeRegistryEntry;
+/**
+ * Get fetch state for a specific scope + query combination
+ * Returns a default FetchState if not found
+ */
+export declare function getFetchState(registry: ScopeRegistry, scope: MenuScope, query: string, parentScope?: MenuScope): FetchState;
+/**
+ * Update fetch state (mutates registry - use inside updateWithImmer!)
+ * Ensures the entry exists in the registry before updating
+ */
+export declare function updateFetchState(registry: ScopeRegistry, scope: MenuScope, query: string, updates: Partial<FetchState>, parentScope?: MenuScope): void;
+/**
+ * Invalidate a scope - removes scope from items and resets fetch states
+ * Use when dynamic data changes (e.g., workspace members updated, tabs closed)
+ *
+ * Items lose this scope but stay in cache if they have other scopes.
+ * Only removes items completely if they have no scopes left.
+ *
+ * @param registry - Registry to mutate
+ * @param cache - Cache to mutate (imported type from item-cache)
+ * @param scope - Scope to invalidate
+ */
+export declare function invalidateScope(registry: ScopeRegistry, cache: ItemCache, scope: MenuScope): void;
+/**
+ * Bind two scopes: browse scope → search scope
+ * When user types a query in the browse scope, UI switches to search scope
+ *
+ * Example:
+ *   bindScopes(registry, 'root', 'global_search')
+ *   → Typing in root scope switches to global_search
+ *
+ * @param registry - Registry to mutate
+ * @param browseScope - The scope shown when browsing (no query)
+ * @param searchScope - The scope shown when searching (has query)
+ */
+export declare function bindScopes(registry: ScopeRegistry, browseScope: MenuScope, searchScope: MenuScope): void;
+/**
+ * Get the search scope for a browse scope (if bound)
+ * Returns null if no binding exists
+ *
+ * @param registry - Registry to read
+ * @param browseScope - The scope to check
+ * @returns Search scope or null
+ */
+export declare function getSearchScope(registry: ScopeRegistry, browseScope: MenuScope): MenuScope | null;
+/**
+ * Check if a scope is configured as flat (no hierarchy)
+ * Returns false if scope not found (safe default = hierarchical)
+ */
+export declare function isFlat(registry: ScopeRegistry, scope: MenuScope): boolean;

package/dist/chat-ui/mentions/suggestions/data/sources/asset-type-icons.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Maps Athena asset types to SVG icon file names.
+ *
+ * The SVG files are bundled by the host app, which declares where they are
+ * served from via `configureAssetIconBasePath`. Hosts that don't bundle them
+ * fall back to the Lucide icons carried on every menu item.
+ */
+/**
+ * Point the mention UI at the host's copy of the asset-type SVGs.
+ * `basePath` is resolved against the host document; a trailing "/" is added
+ * when the caller omits it.
+ */
+export declare function configureAssetIconBasePath({ basePath, }: {
+    basePath: string | null;
+}): void;
+/**
+ * Get the SVG thumbnail URL for an Athena asset type, or undefined when the
+ * host app does not bundle the icon files.
+ */
+export declare function assetTypeToThumb(assetType: string | null | undefined): string | undefined;
+/**
+ * Get Lucide icon name fallback for an asset type.
+ * Used when thumbnailUrl can't load.
+ */
+export declare function assetTypeToIcon(assetType: string | null | undefined): string;

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

@@ -0,0 +1,59 @@
+/**
+ * Mention data sources shared by every chat host.
+ *
+ * Each source function implements the SourceFn interface:
+ *   (context: SourceContext) => Promise<SourceResult>
+ *
+ * Sources are either:
+ * - FETCHERS: Call GraphQL API (assets, folders, team, etc.)
+ * - TRANSFORMERS: Return static/local data (root categories, host-provided items)
+ */
+import type { MenuItem, SourceFn, WebpageMention } from "../types";
+import { type MentionAuthContext } from "../api-client";
+export interface RootCategoriesConfig {
+    categories: string[];
+    getWebpages: () => readonly WebpageMention[];
+}
+export declare function buildRootMenuItems({ categories, webpages, }: {
+    categories: readonly string[];
+    webpages: readonly WebpageMention[];
+}): MenuItem[];
+export declare const transformRootCategories: SourceFn<RootCategoriesConfig>;
+export interface AssetsConfig {
+    auth: MentionAuthContext;
+    limit?: number;
+}
+export declare const fetchAssets: SourceFn<AssetsConfig>;
+export interface FavoritesConfig {
+    auth: MentionAuthContext;
+    limit?: number;
+}
+export declare const fetchFavorites: SourceFn<FavoritesConfig>;
+export interface FoldersConfig {
+    auth: MentionAuthContext;
+    limit?: number;
+}
+export declare const fetchFolders: SourceFn<FoldersConfig>;
+export interface FolderContentsConfig {
+    auth: MentionAuthContext;
+    limit?: number;
+}
+export declare const fetchFolderContents: SourceFn<FolderContentsConfig>;
+export interface TypedAssetsConfig {
+    auth: MentionAuthContext;
+    includeOnlyTypes: string[];
+    limit?: number;
+}
+export declare const fetchTypedAssets: SourceFn<TypedAssetsConfig>;
+export interface TeamConfig {
+    auth: MentionAuthContext;
+}
+export declare const fetchTeam: SourceFn<TeamConfig>;
+export interface DrivesConfig {
+    auth: MentionAuthContext;
+}
+export declare const fetchDrives: SourceFn<DrivesConfig>;
+export interface GlobalSearchConfig {
+    auth: MentionAuthContext;
+}
+export declare const fetchGlobalSearch: SourceFn<GlobalSearchConfig>;

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

@@ -0,0 +1,156 @@
+/**
+ * Core types for mention suggestions data layer
+ */
+/**
+ * MenuScope - A navigable container in the mention menu hierarchy
+ *
+ * Conceptual model:
+ * - SCOPE = Container/Group you navigate INTO (e.g., "athena_assets", "folder_123")
+ * - ITEM = Individual mentionable thing you SELECT (e.g., specific asset, tool)
+ *
+ * Scopes form a navigation hierarchy:
+ *   root → athena_assets → folder_123 → subfolder_456
+ *
+ * Items can be visible in multiple scopes simultaneously:
+ *   Asset "Report.pdf" is in both "folder_123" AND "asset_search" results
+ */
+export type MenuScope = string;
+export declare const MentionMenuSection: {
+    readonly CURRENT_WEBPAGE: "current-webpage";
+    readonly OTHER_WEBPAGES: "other-webpages";
+    readonly LIBRARY: "library";
+};
+export type MentionMenuSection = (typeof MentionMenuSection)[keyof typeof MentionMenuSection];
+export interface WebpageMention {
+    tabId: number;
+    title: string;
+    url: string;
+    isCurrent: boolean;
+}
+export interface WebpageMentionScope {
+    primaryTabId: number;
+    tabGroupId: number | null;
+    allowedTabIds: readonly number[];
+}
+/**
+ * Selector result - provides current state + loading indicators
+ * Used by the UI to get immediate access to data and loading state
+ */
+export interface MenuItemsSelector {
+    items: MenuItem[];
+    isFetching: boolean;
+    hasMore: boolean;
+}
+/**
+ * MenuItem - individual mentionable item
+ * Icon fields match MentionIcon component props exactly - no transforms needed at render time!
+ *
+ * Multi-scope system: Items can belong to multiple scopes simultaneously
+ * Example: An asset can be visible in 'athena_assets', 'folder_123', and 'my_spaces'
+ */
+export interface MenuItem {
+    id: string;
+    name: string;
+    type: 'menu' | 'asset' | 'folder' | 'tool' | 'toolkit' | 'drive' | 'user' | 'task' | 'tab' | 'workspace_item' | 'drive_catalog' | 'placeholder';
+    thumbnailUrl?: string;
+    fallbackIcon: string;
+    visibleInScopes: Set<MenuScope>;
+    navigatesToScope?: MenuScope;
+    isNavigationOnly?: boolean;
+    extra?: Record<string, any>;
+    description?: string;
+    url?: string;
+    menuSection?: MentionMenuSection;
+    updatedAt?: string;
+    email?: string;
+    version?: string;
+    parentMenuId?: string;
+}
+/**
+ * FetchState - fetch status and pagination state for a specific query
+ * Managed by orchestrator, not returned by sources
+ */
+export interface FetchState {
+    isFetching: boolean;
+    hasNextPage: boolean;
+    fetchNext: (() => void) | null;
+    error: Error | null;
+    meta: unknown;
+}
+/**
+ * FetchMetadata - Common metadata fields used by orchestrator
+ * Sources can extend this with their own fields (e.g., pageToken, cursor)
+ */
+export interface FetchMetadata {
+    validatedCount?: number;
+    fetchAttempts?: number;
+    [key: string]: unknown;
+}
+/**
+ * New source to register dynamically
+ * Returned by sources when they discover navigable items (folders, catalogs, etc.)
+ */
+export interface SourceToRegister {
+    scope: MenuScope;
+    sourceFn: SourceFn;
+    sourceConfig?: any;
+    isFlat?: boolean;
+}
+/**
+ * Scope binding to register dynamically
+ * Binds a browse scope to a search scope (hot scope swap on query)
+ */
+export interface ScopeBindingToRegister {
+    browseScope: MenuScope;
+    searchScope: MenuScope;
+}
+/**
+ * Source result - returned by all source functions
+ *
+ * Sources come in two flavors:
+ * 1. TRANSFORMERS - Transform existing data (no API calls)
+ *    Examples: tools, toolkits, workspace members, opened spaces
+ *    Pattern: Read from store/ref → transform → return items
+ *
+ * 2. FETCHERS - Fetch from API (async operations)
+ *    Examples: internal assets, folders, SharePoint items
+ *    Pattern: Call GraphQL/REST → transform response → return items
+ *
+ * 3. HYBRID - Behavior depends on query
+ *    Example: Root menu (transformer when no query, fetcher with query)
+ *
+ * Original design: Sources can return new sources to register!
+ * This allows discovered items (folders, catalogs) to be dynamically registered
+ * without circular dependencies (orchestrator handles registration centrally)
+ */
+export interface SourceResult {
+    items: MenuItem[];
+    pagination?: {
+        hasMore: boolean;
+        totalCount?: number;
+        consumedCount?: number;
+    };
+    meta?: Record<string, unknown>;
+    sources?: SourceToRegister[];
+    bindings?: ScopeBindingToRegister[];
+}
+/**
+ * Source function context
+ *
+ * Sources are pure functions - just fetch/transform and return items!
+ * Orchestrator handles sync/deduplication via Cache.addItems() with scope tagging
+ */
+export interface SourceContext<TConfig = any> {
+    scope: MenuScope;
+    query: string;
+    fetchState: FetchState;
+    sourceConfig: TConfig;
+}
+/**
+ * Source function type
+ *
+ * Pure function that provides items for a scope + query combination.
+ * Can be a transformer (reads from store) or fetcher (calls API).
+ * State (pagination, sourceConfig) is stored externally in registry entry.
+ */
+export type SourceFn<TConfig = any> = (context: SourceContext<TConfig>) => Promise<SourceResult>;

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

@@ -0,0 +1,37 @@
+/**
+ * Chrome Extension Mention Suggestions Store
+ *
+ * Full Olympus-style mention store with all categories:
+ * Favorites, Assets, Projects, Browse Profiles, Folders,
+ * current/group webpages, Team, Workspace, Drives + Global Search.
+ *
+ * Uses registry + cache architecture from Olympus with
+ * async data fetching via GraphQL.
+ */
+import { Store } from "@tanstack/store";
+import { type ItemCache } from "./item-cache";
+import { type ScopeRegistry } from "./scope-registry";
+import type { WebpageMention } from "./types";
+export declare function webpageMentionFingerprint(webpages: readonly WebpageMention[]): string;
+export interface MentionSuggestionsStoreState {
+    registry: ScopeRegistry;
+    cache: ItemCache;
+}
+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 type MentionRootCategory = (typeof ROOT_MENTION_CATEGORIES)[number];
+/**
+ * Creates a stable MentionSuggestionsStore.
+ * Uses MentionAuthCtx for API credentials.
+ */
+export declare function useMentionSuggestions({ webpages, rootCategories, }: {
+    webpages: readonly WebpageMention[];
+    /** Categories shown at the top level; hosts can narrow the default set. */
+    rootCategories?: readonly MentionRootCategory[];
+}): {
+    store: MentionSuggestionsStore;
+    invalidate: (scope: string) => void;
+};

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

@@ -0,0 +1,34 @@
+import type { MenuItem, MenuScope } from './types';
+import type { MentionSuggestionsStore } from './use-mention-suggestions';
+/**
+ * useMenuItems - Like React Query, but for menu items
+ *
+ * Clean, automatic hook that:
+ * - Reads items from store (reactive!)
+ * - Auto-fetches if needed (in useEffect)
+ * - Returns clean interface { items, isFetching, hasMore }
+ *
+ * Usage:
+ * ```typescript
+ * const { items, isFetching, hasMore } = useMenuItems(store, {
+ *   scope: 'athena_folders',
+ *   query: 'doc',
+ *   minItems: 10,
+ *   parentScope: 'root'
+ * });
+ * ```
+ */
+export interface UseMenuItemsOptions {
+    scope: MenuScope;
+    query?: string;
+    minItems?: number;
+    parentScope?: MenuScope;
+}
+export interface UseMenuItemsResult {
+    items: MenuItem[];
+    isFetching: boolean;
+    hasMore: boolean;
+    loadMore: () => void;
+    targetCount: number;
+}
+export declare function useMenuItems(store: MentionSuggestionsStore, options: UseMenuItemsOptions): UseMenuItemsResult;

package/dist/chat-ui/mentions/suggestions/data/utils/filter-items.d.ts

@@ -0,0 +1,13 @@
+import type { MenuItem } from '../types';
+/**
+ * Filter items by query match and sort by relevance
+ *
+ * Note: Items are already filtered by scope in getFilteredItems()
+ * This function only handles query matching and scoring.
+ *
+ * @param items - Items already filtered by scope
+ * @param query - Search query text
+ * @param _scope - Current scope (unused, kept for signature compatibility)
+ * @returns Filtered and sorted items
+ */
+export declare function filterItems(items: MenuItem[], query: string, _scope: string): MenuItem[];

package/dist/chat-ui/mentions/suggestions/data/utils/match-query.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if all words in the query appear in the item name (in any order).
+ * This enables multi-word search like "ask devin" matching "Devin Ask Question".
+ */
+export declare function matchesMultiWordQuery(itemName: string, query: string): boolean;

package/dist/chat-ui/mentions/suggestions/data/utils/score-match.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Calculates a match score for sorting results.
+ * Higher scores indicate better matches.
+ */
+export declare function getMatchScore(itemName: string, query: string): number;

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

@@ -0,0 +1,25 @@
+/**
+ * Tiptap Mention Suggestions Extension
+ *
+ * Integrates the mention popup with Tiptap's suggestion plugin.
+ * Ported from Olympus — same lifecycle management.
+ */
+import { Extension } from "@tiptap/core";
+import type { MentionSuggestionsStore } from "./data/use-mention-suggestions";
+import type { MenuItem } from "./data/types";
+export interface MentionSuggestionRenderProps {
+    query: string;
+    command: (item: MenuItem) => void;
+    clientRect: (() => DOMRect | null) | null;
+    editor: any;
+}
+export type MentionSuggestionCallbacks = {
+    onStart: (props: MentionSuggestionRenderProps) => void;
+    onUpdate: (props: MentionSuggestionRenderProps) => void;
+    onKeyDown: (event: KeyboardEvent) => boolean;
+    onExit: () => void;
+};
+export declare const MentionSuggestionsExtension: Extension<{
+    store: MentionSuggestionsStore | null;
+    callbacks: MentionSuggestionCallbacks | null;
+}, any>;

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

@@ -0,0 +1,19 @@
+/**
+ * Shims for Olympus-specific imports.
+ *
+ * The Olympus mention system imports from @/lib/utils, @/store/*, etc.
+ * These shims provide Chrome-extension-compatible replacements so the
+ * Olympus UI components can be used as-is.
+ */
+import { cn } from "cnfast";
+export { cn };
+export declare const useDebugMenuStore: () => {
+    showDebugMenu: boolean;
+};
+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/message-components.d.ts

@@ -0,0 +1,56 @@
+import { type ToolCallMessagePartComponent } from "@assistant-ui/react";
+import "@assistant-ui/react-markdown/styles/dot.css";
+import type { ButtonHTMLAttributes, FC, ReactNode } from "react";
+import type { ComposerAction } from "../composer/composer-action";
+export declare function IconButton({ children, tooltip, className, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    tooltip: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SmallIconButton({ children, tooltip, className, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    tooltip: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const BranchPicker: FC;
+/** Assistant markdown with Athena mention chips and fenced code blocks. */
+export declare const MarkdownText: FC;
+export declare const UserMessage: FC;
+export interface CreateAssistantMessageOptions {
+    /** Host-registered card for tools without a dedicated UI. */
+    toolFallback: ToolCallMessagePartComponent;
+    /** Extra action-bar controls appended after copy/regenerate. */
+    extraActions?: ReactNode;
+    /**
+     * Renders the message body. Hosts that group content into activity
+     * timelines supply their own; the default renders markdown and tool cards.
+     */
+    content?: FC;
+}
+/**
+ * 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;
+/** 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";
+export declare const THREAD_HEADER_ACTIONS_CLASS = "flex min-w-0 items-center justify-end gap-1.5";
+/** Pill used for the header's leading control (agent picker, host label). */
+export declare const THREAD_HEADER_PILL_CLASS = "inline-flex h-7 max-w-[170px] items-center gap-1.5 rounded-md border border-neutral-200 bg-white px-2 text-xs font-medium text-neutral-800 shadow-sm";
+export declare const THREAD_HEADER_ICON_CLASS = "size-[18px]";
+/** Composer chrome: the dock around the composer, its surface and its rows. */
+export declare const COMPOSER_DOCK_CLASS = "bg-background px-2.5 pb-2 pt-1.5";
+export declare const COMPOSER_SURFACE_CLASS = "relative flex flex-col gap-1 rounded-xl border border-neutral-200 bg-white shadow-[0_2px_10px_rgba(54,45,33,0.08)]";
+export declare const COMPOSER_EDITOR_ROW_CLASS = "px-2.5 pt-1";
+export declare const COMPOSER_TOOLBAR_CLASS = "flex items-center gap-1 border-t border-neutral-100 px-2 py-1.5";
+export declare const THREAD_SCROLL_TO_BOTTOM_CLASS = "inline-flex items-center justify-center rounded-full border bg-background/80 p-1 shadow-sm backdrop-blur transition-opacity hover:bg-accent disabled:invisible";
+/** Stop control shown while a run is in flight and there is nothing queued. */
+export declare const ComposerStopButton: FC<{
+    onStop: () => void;
+    disabled?: boolean;
+    title?: string;
+}>;
+/** Send control, which becomes a queue control while a run is in flight. */
+export declare const ComposerSendButton: FC<{
+    action: Extract<ComposerAction, "send" | "queue">;
+    onSend: () => void;
+    disabled?: boolean;
+    title?: string;
+}>;

package/dist/chat-ui/messages/running-indicator.d.ts

@@ -0,0 +1,10 @@
+import type { ThreadMessage } from "@assistant-ui/react";
+import type { FC } from "react";
+export declare function hasVisibleContent(content: ThreadMessage["content"]): boolean;
+export declare const TextShimmerLoader: FC<{
+    text?: string;
+    className?: string;
+}>;
+export declare const ThreadRunningIndicator: FC<{
+    text?: string;
+}>;

package/dist/chat-ui/thread/chat-composer-dock.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+export interface ChatComposerDockProps {
+    /** Rendered inside the dock, above the composer surface (error banners). */
+    aboveSurface?: ReactNode;
+    /**
+     * Rendered inside the surface above the editor row: context chips,
+     * restore notices, attachment strips.
+     */
+    beforeEditor?: ReactNode;
+    /** The editor element (a TiptapComposer, typically ref-held by the host). */
+    editor: ReactNode;
+    /** Toolbar contents before the spacer (attach buttons, pickers). */
+    toolbarStart?: ReactNode;
+    /** Toolbar contents after the spacer (voice, capture, send/stop). */
+    toolbarEnd: ReactNode;
+}
+/**
+ * The shared composer scaffolding: dock padding, the bordered surface, the
+ * editor row, and the toolbar with its start/end slots around a flexible
+ * spacer. Hosts supply the editor element and toolbar controls.
+ */
+export declare function ChatComposerDock({ aboveSurface, beforeEditor, editor, toolbarStart, toolbarEnd, }: ChatComposerDockProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,46 @@
+import type { FC, ReactNode } from "react";
+export interface ChatThreadMessageComponents {
+    UserMessage: FC;
+    AssistantMessage: FC;
+}
+export interface ChatThreadShellProps {
+    /**
+     * Rendered above the viewport, inside the panel: header rows, slide-over
+     * panels, and anything else the host docks at the top.
+     */
+    header?: ReactNode;
+    /** Status/approval banners rendered between the header and the viewport. */
+    banners?: ReactNode;
+    /**
+     * Nodes rendered inside the scroll viewport before the message column —
+     * absolutely-positioned overlays (thread-switch skeletons) and invisible
+     * observers (read receipts).
+     */
+    viewportOverlay?: ReactNode;
+    /** Empty-thread state, rendered via ThreadPrimitive.Empty when provided. */
+    welcome?: ReactNode;
+    /** Message renderers for ThreadPrimitive.Messages. */
+    components: ChatThreadMessageComponents;
+    /**
+     * Wraps the messages element — for hosts that provide message-scoped
+     * context (e.g. activity-grouping providers). Must render its argument.
+     */
+    renderMessages?: (messages: ReactNode) => ReactNode;
+    /**
+     * Rendered between the viewport and the composer: connection banners,
+     * queued-message trays.
+     */
+    belowViewport?: ReactNode;
+    /** The composer dock (or a read-only notice replacing it). */
+    composer?: ReactNode;
+}
+/**
+ * The shared side-panel/task-pane thread layout: panel chrome, scroll
+ * viewport with welcome + messages + running indicator, the sticky
+ * scroll-to-bottom control, and the host-supplied composer dock.
+ *
+ * Hosts express their genuine divergences through the slots above; the
+ * layout, scroll behaviour, and empty/running states stay identical across
+ * surfaces so fixes land once.
+ */
+export declare function ChatThreadShell({ header, banners, viewportOverlay, welcome, components, renderMessages, belowViewport, composer, }: ChatThreadShellProps): import("react/jsx-runtime").JSX.Element;