@athenaintel/react 0.10.33 → 0.10.35

package/dist/runtime/useAthenaRuntime.d.ts

@@ -0,0 +1,47 @@
+import type { AssistantRuntime } from '@assistant-ui/react';
+export { DEFAULT_API_URL, DEFAULT_BACKEND_URL } from '../lib/athena-urls';
+export interface AthenaRuntimeConfig {
+    /** URL for the chat streaming endpoint. Defaults to Athena production sync server. */
+    apiUrl?: string;
+    /** URL for the sync server resume endpoint. Derived from apiUrl if not provided. */
+    resumeApiUrl?: string;
+    /** URL for the Athena backend API. Defaults to Athena production API. */
+    backendUrl?: string;
+    /** API key for authentication. Used when no auth token is provided. */
+    apiKey?: string;
+    /** PropelAuth token from parent window. Takes priority over apiKey. */
+    token?: string | null;
+    /** Resolve the latest token immediately before a request (for expiring clients). */
+    getToken?: () => string | null | Promise<string | null>;
+    /** Called when the transport reports an authentication failure. */
+    onUnauthorized?: () => void | Promise<void>;
+    /** LLM model identifier. */
+    model?: string;
+    /** Agent name to use. */
+    agent?: string;
+    /** Backend toolkit IDs to enable. */
+    tools?: string[];
+    /** Frontend tool IDs to include in enabled_tools. */
+    frontendToolIds?: string[];
+    /** Asset IDs to include in the workbench. */
+    workbench?: string[];
+    /** Knowledge base IDs for RAG context. */
+    knowledgeBase?: string[];
+    /** System prompt override. */
+    systemPrompt?: string;
+    /** Custom tool configurations (e.g. MCP servers). Passed as custom_tool_configs in runConfig. */
+    customToolConfigs?: Record<string, unknown>;
+    /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */
+    appId?: string;
+    /** Thread ID override. Auto-generated if not provided. */
+    threadId?: string;
+    /** Request channel. Defaults to "web". Use "chrome_extension" for the browser extension. */
+    channel?: string;
+    /** Device ID for device tunnel routing (chrome extension). */
+    deviceId?: string;
+    /** Additional fields merged into the request body. */
+    extraBody?: Record<string, unknown>;
+    /** Additional fields merged into runConfig.custom. */
+    extraRunConfig?: Record<string, unknown>;
+}
+export declare const useAthenaRuntime: (config: AthenaRuntimeConfig) => AssistantRuntime;

package/dist/theme/index.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Athena SDK Theming System
+ *
+ * Usage:
+ *   import { AthenaProvider, themes } from '@athenaintel/react';
+ *
+ *   // Use a preset theme
+ *   <AthenaProvider theme={themes.dark}>
+ *
+ *   // Customize a preset
+ *   <AthenaProvider theme={{ ...themes.dark, primary: '#8b5cf6' }}>
+ *
+ *   // Full custom theme
+ *   <AthenaProvider theme={{ primary: '#2563eb', background: '#fafafa', radius: '1rem' }}>
+ */
+export interface AthenaTheme {
+    /** Brand / accent color. Send button, active states, focus ring, spinner. */
+    primary?: string;
+    /** Text color on primary background. Set this with `primary` when you change contrast significantly. */
+    primaryForeground?: string;
+    /** Page / panel background. */
+    background?: string;
+    /** Primary text color. */
+    foreground?: string;
+    /** Subtle background. User message bubble, sidebar hover, thread highlight. */
+    muted?: string;
+    /** De-emphasized text. Timestamps, placeholders, sidebar items. */
+    mutedForeground?: string;
+    /** Hover / focus highlight background. */
+    accent?: string;
+    /** Text on accent background. */
+    accentForeground?: string;
+    /** Secondary surface color. */
+    secondary?: string;
+    /** Text on secondary surface. */
+    secondaryForeground?: string;
+    /** Card / modal surface color. */
+    card?: string;
+    /** Text on card surface. */
+    cardForeground?: string;
+    /** Popover / tooltip / dropdown surface. */
+    popover?: string;
+    /** Text on popover surface. */
+    popoverForeground?: string;
+    /** Error / danger color. Error banners, delete actions. */
+    destructive?: string;
+    /** Default border color. Dividers, card borders. */
+    border?: string;
+    /** Input field border color. Composer border. */
+    input?: string;
+    /** Focus ring color. Composer focus ring. */
+    ring?: string;
+    /** Base border radius for all rounded corners. e.g. '0.5rem', '0.75rem', '0' */
+    radius?: string;
+    /** Font family for all text. e.g. "'Inter', sans-serif", "system-ui" */
+    fontFamily?: string;
+    /** Sidebar background color. Falls back to muted with transparency. */
+    sidebarBackground?: string;
+    /** Sidebar border color. Falls back to border. */
+    sidebarBorder?: string;
+    /** Sidebar width. e.g. '280px', '20rem'. */
+    sidebarWidth?: string;
+    /** User message bubble background. Falls back to muted. */
+    userBubble?: string;
+    /** User message bubble text color. Falls back to foreground. Set this when `userBubble` is dark or saturated. */
+    userBubbleForeground?: string;
+    /** User message bubble border radius. e.g. '1rem', '0.5rem'. */
+    userBubbleRadius?: string;
+    /** Assistant message text color. Falls back to foreground. Set this when `assistantBubble` reduces contrast. */
+    assistantForeground?: string;
+    /** Assistant message bubble background. Transparent by default. */
+    assistantBubble?: string;
+    /** Composer border color. Falls back to input. */
+    composerBorder?: string;
+    /** Composer border radius. Falls back to radius-based default. */
+    composerRadius?: string;
+    /** Max width of the chat thread area. e.g. '44rem', '56rem'. */
+    threadMaxWidth?: string;
+}
+/** Convert an AthenaTheme object to a CSS variables style object. */
+export declare function themeToStyleVars(theme: AthenaTheme): Record<string, string>;
+export declare const themes: {
+    /** Default light theme. Neutral grays with blue accent. */
+    readonly light: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+    /** Dark theme. Deep gray background with lighter text. */
+    readonly dark: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+    /** Midnight theme. Deep navy with soft blue tones. */
+    readonly midnight: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+    /** Warm earthy theme. Brown and sand tones. */
+    readonly warm: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+    /** Purple creative theme. Vibrant purple accent. */
+    readonly purple: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+    /** Green nature theme. Fresh green tones. */
+    readonly green: {
+        background: string;
+        foreground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        destructive: string;
+        border: string;
+        input: string;
+        ring: string;
+        radius: string;
+    };
+};

package/dist/threads/ThreadList.d.ts

@@ -0,0 +1,4 @@
+export interface ThreadListProps {
+    className?: string;
+}
+export declare function ThreadList({ className }: ThreadListProps): import("react/jsx-runtime").JSX.Element;

package/dist/threads/adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * RemoteThreadListAdapter implementation for Athena/Agora backend.
+ * Maps our Agora API to the assistant-ui RemoteThreadListAdapter interface.
+ *
+ * Message loading for existing threads happens via the sync server's resume API
+ * (triggered by useAthenaRuntime), NOT via a ThreadHistoryAdapter.
+ */
+import type { RemoteThreadListAdapter } from '@assistant-ui/react';
+interface AthenaThreadListAdapterConfig {
+    backendUrl: string;
+    apiKey?: string;
+    token?: string | null;
+    appId?: string;
+}
+/**
+ * Context for passing the current thread's remoteId from the unstable_Provider
+ * down to the runtimeHook, without requiring useAui() in the hook.
+ */
+export declare const AthenaThreadIdContext: import("react").Context<string | undefined>;
+/**
+ * Read the current assistant-ui thread item's remote ID.
+ *
+ * This must be used inside assistant-ui's ThreadListItemRuntimeProvider.
+ * It is available before `unstable_Provider` renders its children, so the
+ * per-thread runtime hook can use it to hydrate existing threads.
+ */
+export declare function useAthenaAuiThreadRemoteId(): string | undefined;
+/** Read the current thread's remote ID (set by the adapter's unstable_Provider). */
+export declare function useAthenaThreadId(): string | undefined;
+/**
+ * Hook that returns a RemoteThreadListAdapter for the Athena platform.
+ * Integrates with our Agora REST API for thread CRUD.
+ */
+export declare function useAthenaThreadListAdapter(config: AthenaThreadListAdapterConfig): RemoteThreadListAdapter;
+/**
+ * Context for exposing a thread list refresh callback.
+ * Provided by AthenaWithThreadList, consumed by ThreadList.
+ */
+export declare const ThreadListRefreshContext: import("react").Context<(() => void) | null>;
+/** Trigger a re-fetch of the thread list. No-op outside of thread list mode. */
+export declare function useRefreshThreadList(): (() => void) | null;
+export {};

package/dist/threads/api.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Athena thread API client.
+ * Calls existing REST endpoints for thread CRUD.
+ */
+export interface ThreadSummary {
+    thread_id: string;
+    title: string;
+    created_at: string;
+    updated_at: string;
+    last_message: string | null;
+    message_count: number;
+    state: string | null;
+}
+export interface ThreadListResponse {
+    threads: ThreadSummary[];
+}
+export interface ThreadCreateResponse {
+    thread_id: string;
+}
+interface AuthConfig {
+    apiKey?: string;
+    token?: string | null;
+}
+export declare function listThreads(backendUrl: string, auth: AuthConfig, opts?: {
+    limit?: number;
+    offset?: number;
+    exclude_triggered?: boolean;
+    app_id?: string;
+}): Promise<ThreadListResponse>;
+export declare function createThread(backendUrl: string, auth: AuthConfig, opts?: {
+    systemPrompt?: string;
+    enabledTools?: string[];
+    appId?: string;
+}): Promise<ThreadCreateResponse>;
+export interface ThreadStateResponse {
+    thread_id: string;
+    messages: unknown[];
+    status?: string;
+    [key: string]: unknown;
+}
+/**
+ * Fetch persisted thread state from the conversations API.
+ *
+ * This endpoint is the same source used by Athena's conversation sidebar and
+ * supports API-key auth plus BYO SSO session tokens sent as Bearer tokens.
+ */
+export declare function getThreadState(backendUrl: string, auth: AuthConfig, threadId: string): Promise<ThreadStateResponse>;
+export declare function archiveThread(backendUrl: string, auth: AuthConfig, threadId: string): Promise<void>;
+export {};

package/dist/threads/index.d.ts

@@ -0,0 +1,5 @@
+export { ThreadList } from './ThreadList';
+export type { ThreadListProps } from './ThreadList';
+export type { ThreadSummary } from './api';
+export { useAthenaThreadManager } from './useAthenaThreadManager';
+export type { AthenaThreadManagerState } from './useAthenaThreadManager';

package/dist/threads/title.d.ts

@@ -0,0 +1,4 @@
+import type { ThreadMessage } from "@assistant-ui/react";
+export declare function isSerializedContentPartsTitle(title: string): boolean;
+export declare function normalizeThreadTitle(title: string | null | undefined): string | undefined;
+export declare function getFallbackTitleFromMessages(messages: readonly ThreadMessage[]): string;

package/dist/threads/useActiveThreadStateHydration.d.ts

@@ -0,0 +1,14 @@
+interface ActiveThreadStateHydrationConfig {
+    backendUrl: string;
+    apiKey?: string;
+    token?: string | null;
+}
+type HydratableThreadState = {
+    metadata?: {
+        remoteId?: string;
+    };
+    threadId: string;
+};
+export declare const selectHydratableThreadId: (state: HydratableThreadState) => string | null;
+export declare function useActiveThreadStateHydration({ backendUrl, apiKey, token, }: ActiveThreadStateHydrationConfig): void;
+export {};

package/dist/threads/useAthenaThreadManager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Public hook for managing thread state and navigation.
+ *
+ * Wraps the underlying runtime to provide a clean, Athena-branded API
+ * for reading the active thread, listing threads, and switching between them.
+ *
+ * Must be used inside `<AthenaProvider enableThreadList>`.
+ */
+import { type ThreadListState } from '@assistant-ui/react';
+export interface AthenaThreadManagerState {
+    /** The backend thread ID of the currently active thread, or null if not yet synced. */
+    activeThreadId: string | null;
+    /** Whether the thread list is still loading from the backend. */
+    isListLoading: boolean;
+    /** Whether the current thread is loading its message history (e.g. after a thread switch). */
+    isThreadLoading: boolean;
+    /** Switch the chat to a different thread by its backend thread ID. */
+    switchToThread: (threadId: string) => Promise<void>;
+    /** Create and switch to a new empty thread. */
+    switchToNewThread: () => Promise<void>;
+}
+type ActiveThreadState = Pick<ThreadListState, 'mainThreadId' | 'threadItems'>;
+export declare const selectActiveThreadRemoteId: (state: ActiveThreadState) => string | null;
+export declare function useAthenaThreadManager(): AthenaThreadManagerState | null;
+export {};

package/dist/threads/useThreadTitlePolling.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Internal hook that polls the thread list to pick up a freshly-generated
+ * title after the user sends the first message in a new thread.
+ *
+ * The Agora backend generates thread titles asynchronously from the first
+ * user message, so the title usually isn't available at the moment the
+ * thread is created. Without this, new threads show as "New conversation"
+ * in the sidebar until the user manually refreshes.
+ *
+ * Triggers when the active thread has messages but no title yet, then
+ * polls every second (after a 5s initial delay) until a title appears
+ * or a max duration elapses.
+ */
+export declare function useThreadTitlePolling(refresh: () => void): void;

package/dist/toolkits/index.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Backend toolkit IDs.
+ *
+ * Pass these to the `tools` prop on `<AthenaProvider>` to enable backend toolkits.
+ *
+ * @example
+ * import { Toolkits } from '@athenaintel/react';
+ *
+ * <AthenaProvider tools={[Toolkits.DOCUMENT, Toolkits.SPREADSHEET, Toolkits.WEB_SEARCH]}>
+ */
+export declare const Toolkits: {
+    /** Web search and page browsing. */
+    readonly WEB_SEARCH: 'web_search_browse_toolkit';
+    /** SQL query execution. */
+    readonly SQL: 'sql_toolkit';
+    /** Azure Blob Storage catalog file operations. */
+    readonly AZURE_BLOB_STORAGE: 'azure_blob_storage_toolkit';
+    /** Document comments and collaboration. */
+    readonly COMMENTS: 'comments_toolkit';
+    /** Visual canvas creation. */
+    readonly CANVAS: 'canvas_toolkit';
+    /** PostgreSQL database management. */
+    readonly DATABASE: 'database_toolkit';
+    /** Asset collections management. */
+    readonly COLLECTIONS: 'collections_toolkit';
+    /** Charts, dashboards, and figures. */
+    readonly VISUALIZATIONS: 'visualizations_toolkit';
+    /** Custom UI creation. */
+    readonly USER_INTERFACE: 'user_interface_toolkit';
+    /** Agent Operating Procedures. */
+    readonly AOP: 'aop_toolkit';
+    /** Ephemeral compute environments. */
+    readonly COMPUTER_ASSET: 'computer_asset_toolkit';
+    /** Web browser automation. */
+    readonly BROWSER: 'browser_toolkit';
+    /** Virtual machine management. */
+    readonly VM: 'vm_toolkit';
+    /** Jupyter notebook execution. */
+    readonly NOTEBOOK: 'notebook_toolkit';
+    /** Presentation slide editing. */
+    readonly PRESENTATION: 'presentation_toolkit';
+    /** Presentation slide editing (OnlyOffice, deprecated). */
+    readonly PRESENTATION_ONLYOFFICE: 'presentation_onlyoffice_toolkit';
+    /** PowerPoint presentation creation from templates. */
+    readonly POWERPOINT: 'powerpoint_deck_toolkit';
+    /** PowerPoint presentation creation from templates (pptx-studio). */
+    readonly PRESENTATION_PPTX_STUDIO: 'presentation_pptx_studio_toolkit';
+    /** Workspace file management (Olympus Drive). */
+    readonly DRIVE: 'olympus_drive_toolkit';
+    /** Python code execution. */
+    readonly PYTHON: 'python_toolkit';
+    /** Multi-account email and calendar (Gmail + Outlook). */
+    readonly EMAIL: 'unified_email_toolkit';
+    /** Legacy email and calendar operations. */
+    readonly EMAIL_CALENDAR: 'email_calendar_toolkit';
+    /** Spreadsheet operations. */
+    readonly SPREADSHEET: 'spreadsheet_toolkit';
+    /** Athena document editing. */
+    readonly DOCUMENT: 'document_toolkit';
+    /** Word document backend operations. */
+    readonly WORD_DOCUMENT: 'word_document_be_toolkit';
+    /** Go-To-Market management. */
+    readonly GTM: 'gtm_toolkit';
+    /** Marketing campaign management. */
+    readonly MARKETING: 'marketing_toolkit';
+    /** FDE implementations and workflows. */
+    readonly FDE: 'fde_toolkit';
+    /** SharePoint / Google Drive / workspace file access. */
+    readonly EXTERNAL_DRIVE: 'external_drive_toolkit';
+    /** Reusable playbooks and prompts. */
+    readonly PLAYBOOK: 'playbook_toolkit';
+    /** Local Chrome browser control via tunnel. */
+    readonly DEVICE_TUNNEL: 'device_tunnel_toolkit';
+    /** Project management. */
+    readonly PROJECTS: 'projects_toolkit';
+    /** Task Studio script execution. */
+    readonly TASK_STUDIO: 'task_studio_toolkit';
+    /** User memory and preferences. */
+    readonly PREFERENCES: 'preferences_toolkit';
+};
+/** A toolkit ID string. */
+export type ToolkitId = (typeof Toolkits)[keyof typeof Toolkits];
+export interface ToolkitDisplayInfo {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+}
+export declare const getToolkitDisplayInfo: (id: string) => ToolkitDisplayInfo;

package/dist/tools/NestedPtcMessages.d.ts

@@ -0,0 +1,14 @@
+import { MessagePrimitive } from "@assistant-ui/react";
+import { type ComponentProps, type FC, type PropsWithChildren } from "react";
+import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+type PartsComponents = ComponentProps<typeof MessagePrimitive.Parts>["components"];
+export declare const NestedPtcComponentsProvider: FC<PropsWithChildren<{
+    components: PartsComponents;
+}>>;
+export declare const useNestedPtcComponents: (fallback: ToolCallMessagePartComponent) => PartsComponents;
+export interface NestedPtcMessagesProps {
+    components: PartsComponents;
+    messageClassName?: string;
+}
+export declare const NestedPtcMessages: FC<NestedPtcMessagesProps>;
+export {};

package/dist/tools/append-document-tool-ui.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+export declare const AppendDocumentToolUI: ToolCallMessagePartComponent;

package/dist/tools/asset-utils.d.ts

@@ -0,0 +1,6 @@
+export type AssetIconType = "doc" | "pdf" | "sheet";
+export declare function getAssetInfo(assetId: string): {
+    name: string;
+    icon: AssetIconType;
+};
+export declare function tryParseJson(text: string): Record<string, unknown> | null;

package/dist/tools/auto-open-tools.d.ts

@@ -0,0 +1,8 @@
+import type { Toolkit } from '@assistant-ui/react';
+/**
+ * Default frontend tools that auto-open the asset a tool just created or
+ * touched. Registered automatically by `AthenaProvider` / `AthenaChat`; pass
+ * `disableAutoOpen` to turn off, or override individual entries via
+ * `frontendTools`.
+ */
+export declare const DEFAULT_AUTO_OPEN_TOOLS: Toolkit;

package/dist/tools/read-asset-tool-ui.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+export declare const ReadAssetToolUI: ToolCallMessagePartComponent;

package/dist/tools/tool-fallback.d.ts

@@ -0,0 +1,34 @@
+import { type ToolCallMessagePartStatus, type ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible";
+export declare function clearAutoOpenedAssets(): void;
+export type ToolFallbackRootProps = Omit<React.ComponentProps<typeof Collapsible>, "open" | "onOpenChange"> & {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+};
+declare function ToolFallbackRoot({ className, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen, children, ...props }: ToolFallbackRootProps): import("react/jsx-runtime").JSX.Element;
+declare function ToolFallbackTrigger({ toolName, argsText, result, status, className, ...props }: React.ComponentProps<typeof CollapsibleTrigger> & {
+    toolName: string;
+    argsText?: string;
+    result?: unknown;
+    status?: ToolCallMessagePartStatus;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToolFallbackContent({ className, children, ...props }: React.ComponentProps<typeof CollapsibleContent>): import("react/jsx-runtime").JSX.Element;
+declare function ToolFallbackArgs({ argsText, className, ...props }: React.ComponentProps<"div"> & {
+    argsText?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function ToolFallbackResult({ result, className, ...props }: React.ComponentProps<"div"> & {
+    result?: unknown;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function ToolFallbackError({ status, className, ...props }: React.ComponentProps<"div"> & {
+    status?: ToolCallMessagePartStatus;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare const ToolFallback: ToolCallMessagePartComponent & {
+    Root: typeof ToolFallbackRoot;
+    Trigger: typeof ToolFallbackTrigger;
+    Content: typeof ToolFallbackContent;
+    Args: typeof ToolFallbackArgs;
+    Result: typeof ToolFallbackResult;
+    Error: typeof ToolFallbackError;
+};
+export { ToolFallback, ToolFallbackRoot, ToolFallbackTrigger, ToolFallbackContent, ToolFallbackArgs, ToolFallbackResult, ToolFallbackError, };

package/dist/tools/tool-uis.d.ts

@@ -0,0 +1,62 @@
+import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { type AssetType } from "../assets/asset-panel-store";
+export declare function normalizeResult(result: unknown): Record<string, unknown> | null;
+export declare function truncate(text: string, max: number): string;
+/** Format a tool name like `create_new_sheet` → "Create New Sheet" */
+export declare function formatToolName(name: string): string;
+export type ToolStatus = "running" | "complete" | "incomplete" | "requires-action";
+export declare function ToolCard({ icon: Icon, status, title, subtitle, toolName, badge, error, children, args, result, }: {
+    icon: React.ElementType;
+    status: ToolStatus;
+    title: string;
+    subtitle?: string;
+    toolName?: string;
+    badge?: string;
+    error?: string | null;
+    children?: React.ReactNode;
+    args?: Record<string, unknown>;
+    result?: unknown;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ExpandableSection({ label, children, defaultOpen, }: {
+    label?: string;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const WebSearchToolUI: ToolCallMessagePartComponent;
+export declare const BrowseToolUI: ToolCallMessagePartComponent;
+export declare const EmailSearchToolUI: ToolCallMessagePartComponent;
+export declare function resetAssetAutoOpen(): void;
+export declare const CreateDocumentToolUI: ToolCallMessagePartComponent;
+export declare const CreateSheetToolUI: ToolCallMessagePartComponent;
+export declare const CreatePresentationToolUI: ToolCallMessagePartComponent;
+export declare const StudioCreateWorkbookToolUI: ToolCallMessagePartComponent;
+export declare const StudioAddSheetToolUI: ToolCallMessagePartComponent;
+export declare const StudioOpenWorkbookToolUI: ToolCallMessagePartComponent;
+export declare const StudioCreatePresentationToolUI: ToolCallMessagePartComponent;
+export declare const StudioOpenPresentationToolUI: ToolCallMessagePartComponent;
+export declare const StudioAddSlideToolUI: ToolCallMessagePartComponent;
+export declare const StudioCreateDocumentToolUI: ToolCallMessagePartComponent;
+export declare const StudioCreateParagraphToolUI: ToolCallMessagePartComponent;
+export declare const StudioOpenDocumentToolUI: ToolCallMessagePartComponent;
+export declare const CreateEmailDraftToolUI: ToolCallMessagePartComponent;
+export declare const CreateNotebookToolUI: ToolCallMessagePartComponent;
+export declare const RunPythonCodeToolUI: ToolCallMessagePartComponent;
+export declare const ExecutePresentationCodeToolUI: ToolCallMessagePartComponent;
+export declare const OpenAssetToolUI: ToolCallMessagePartComponent;
+export declare const DescribeDatabaseToolUI: ToolCallMessagePartComponent;
+export declare const ListDatabaseTablesToolUI: ToolCallMessagePartComponent;
+export declare const GetDatabaseTableSchemaToolUI: ToolCallMessagePartComponent;
+export declare const RunSqlToolUI: ToolCallMessagePartComponent;
+export declare const UpdateSheetRangeToolUI: ToolCallMessagePartComponent;
+export declare const BulkFormatSheetRangeToolUI: ToolCallMessagePartComponent;
+export declare const SetRowColumnDimensionsToolUI: ToolCallMessagePartComponent;
+export declare function createAssetToolUI(config: {
+    icon: React.ElementType;
+    assetType: AssetType;
+    runningLabel: string;
+    doneLabel: string;
+}): ToolCallMessagePartComponent;
+export declare const CaptureMomentToolUI: ToolCallMessagePartComponent;
+export declare const CaptureSlideScreenshotToolUI: ToolCallMessagePartComponent;
+export declare const OpenBrowserToolUI: ToolCallMessagePartComponent;
+export declare const TOOL_UI_REGISTRY: Record<string, ToolCallMessagePartComponent>;