@athenaintel/react 0.10.34 → 0.10.36

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;

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

@@ -0,0 +1,9 @@
+/**
+ * Default `getToolGroupKey` implementation used by the SDK's tool grouping.
+ * Returns the toolkit display key for a tool name, or `undefined` if the tool
+ * is ungrouped or unknown.
+ *
+ * Override per-app by passing `getToolGroupKey` to `<AthenaChat>`.
+ */
+export declare const defaultGetToolGroupKey: (toolName: string) => string | undefined;
+export type GetToolGroupKey = (toolName: string) => string | undefined;

package/dist/chat/tiptap-composer.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from "react";
+import { type MentionTool, type MentionRootCategory } from "../mentions/use-mention-suggestions";
+export interface TiptapComposerProps {
+    tools?: MentionTool[];
+    rootCategories?: readonly MentionRootCategory[];
+}
+export declare const TiptapComposer: FC<TiptapComposerProps>;

package/dist/chat/tiptap-text.d.ts

@@ -0,0 +1,4 @@
+import type { FC } from "react";
+export declare const TiptapText: FC<{
+    text: string;
+}>;

package/dist/chat/tooltip-icon-button.d.ts

@@ -0,0 +1,7 @@
+import { ComponentPropsWithRef } from "react";
+import { Button } from "../ui/button";
+export type TooltipIconButtonProps = ComponentPropsWithRef<typeof Button> & {
+    tooltip: string;
+    side?: "top" | "bottom" | "left" | "right";
+};
+export declare const TooltipIconButton: import("react").ForwardRefExoticComponent<Omit<TooltipIconButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/composer/AttachmentContext.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import type { UploadedAsset } from './useFileUpload';
+interface AttachmentContextValue {
+    attachments: UploadedAsset[];
+    addAttachments: (assets: UploadedAsset[]) => void;
+    removeAttachment: (id: string) => void;
+    clearAttachments: () => void;
+    /** True when one or more files are currently being uploaded. */
+    isUploading: boolean;
+    setIsUploading: (v: boolean) => void;
+}
+export declare function AttachmentProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAttachments(): AttachmentContextValue;
+/**
+ * Build the markdown references for the current attachments.
+ * Returns empty string if no attachments.
+ *
+ * @deprecated Use `buildAttachmentMarkdownWithAppUrl` to avoid defaulting links to the production Athena app URL.
+ */
+export declare function buildAttachmentMarkdown(attachments: UploadedAsset[]): string;
+export declare function buildAttachmentMarkdownWithAppUrl({ attachments, appUrl, }: {
+    attachments: UploadedAsset[];
+    appUrl?: string;
+}): string;
+export {};

package/dist/composer/ComposerAttachmentPreview.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+export interface ComposerAttachmentPreviewProps {
+    className?: string;
+}
+/**
+ * Renders uploaded file pills above the composer.
+ * Each pill shows the file name and a dismiss button.
+ */
+export declare const ComposerAttachmentPreview: FC<ComposerAttachmentPreviewProps>;

package/dist/composer/ComposerDropZone.d.ts

@@ -0,0 +1,13 @@
+import { type FC, type ReactNode } from 'react';
+import { type UploadedAsset } from './useFileUpload';
+export interface ComposerDropZoneProps {
+    children: ReactNode;
+    className?: string;
+    /** Called after files are uploaded via drag-and-drop. */
+    onUpload?: (assets: UploadedAsset[]) => void;
+}
+/**
+ * Wraps the composer area with drag-and-drop file upload support.
+ * Shows a visual drop indicator when files are dragged over.
+ */
+export declare const ComposerDropZone: FC<ComposerDropZoneProps>;

package/dist/composer/ComposerQuotePreview.d.ts

@@ -0,0 +1,12 @@
+import type { FC } from 'react';
+export interface ComposerQuotePreviewProps {
+    className?: string;
+}
+/**
+ * Renders a quote preview pill above the composer when text has been quoted
+ * (via Cmd+L, text selection, or PostMessage from an iframe).
+ *
+ * Shows the quoted text with source attribution and a dismiss button.
+ * Clears automatically after message send (handled by ComposerWithQuote).
+ */
+export declare const ComposerQuotePreview: FC<ComposerQuotePreviewProps>;

package/dist/composer/FileUploadButton.d.ts

@@ -0,0 +1,15 @@
+import { type FC } from 'react';
+import { type UploadedAsset } from './useFileUpload';
+export interface FileUploadButtonProps {
+    className?: string;
+    /** Called after files are uploaded successfully. Receives the created assets. */
+    onUpload?: (assets: UploadedAsset[]) => void;
+    /** Accepted file types (MIME pattern). Defaults to all files. */
+    accept?: string;
+}
+/**
+ * Paperclip button that opens a file picker and uploads selected files to Athena.
+ * After upload, adds files to the attachment context so they appear as pills
+ * above the composer and get included when the message is sent.
+ */
+export declare const FileUploadButton: FC<FileUploadButtonProps>;

package/dist/composer/QuoteContext.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+export interface QuoteData {
+    /** The selected/quoted text. */
+    text: string;
+    /** Title of the source (e.g., asset title, document name). */
+    sourceTitle?: string;
+    /** Asset ID of the source (for attribution). */
+    sourceAssetId?: string;
+    /** Message ID of the source message (when quoting from chat). */
+    sourceMessageId?: string;
+    /** Role of the source message ('assistant' | 'user'). */
+    sourceRole?: string;
+}
+interface QuoteContextValue {
+    quote: QuoteData | null;
+    setQuote: (quote: QuoteData | null) => void;
+    clearQuote: () => void;
+}
+export declare function QuoteProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useQuote(): QuoteContextValue;
+/**
+ * Listens for:
+ * 1. Cmd+L / Ctrl+L keydown — grabs the current text selection and sets it as a quote.
+ *    `preventDefault` stops the browser from focusing the URL bar.
+ * 2. PostMessage events from child iframes (asset panels, embedded content)
+ *    with type `athena-add-to-composer`.
+ *
+ * Mount this once inside AthenaProvider.
+ */
+export declare function useQuoteFromPostMessage(): void;
+export {};

package/dist/composer/build-composed-message.d.ts

@@ -0,0 +1,15 @@
+import type { UploadedAsset } from './useFileUpload';
+import type { QuoteData } from './QuoteContext';
+/**
+ * Assembles a composed message from attachments, a quote, and user text.
+ * Used by both the TipTap Enter-key submit and the send-button click handler
+ * to avoid duplicating the message-assembly logic.
+ *
+ * Returns an empty string if all inputs are empty.
+ */
+export declare function buildComposedMessage(opts: {
+    attachments?: UploadedAsset[];
+    quote?: QuoteData | null;
+    userText?: string;
+    appUrl?: string;
+}): string;

package/dist/composer/clipboard.d.ts

@@ -0,0 +1,6 @@
+export declare function shouldPrioritizeTextOverImage({ clipboardData, }: {
+    clipboardData: DataTransfer;
+}): boolean;
+export declare function getClipboardImageFiles({ clipboardData, }: {
+    clipboardData: DataTransfer;
+}): File[];

package/dist/composer/index.d.ts

@@ -0,0 +1,18 @@
+export { useAppendToComposer } from './useAppendToComposer';
+export { useSendMessage } from './useSendMessage';
+export type { SendMessageOptions } from './useSendMessage';
+export { useComposerAttachment } from './useComposerAttachment';
+export { useFileUpload } from './useFileUpload';
+export type { UploadedAsset, UploadProgress, UseFileUploadReturn } from './useFileUpload';
+export { FileUploadButton } from './FileUploadButton';
+export type { FileUploadButtonProps } from './FileUploadButton';
+export { ComposerQuotePreview } from './ComposerQuotePreview';
+export type { ComposerQuotePreviewProps } from './ComposerQuotePreview';
+export { ComposerAttachmentPreview } from './ComposerAttachmentPreview';
+export type { ComposerAttachmentPreviewProps } from './ComposerAttachmentPreview';
+export { AttachmentProvider, useAttachments } from './AttachmentContext';
+export { QuoteProvider, useQuote, useQuoteFromPostMessage } from './QuoteContext';
+export type { QuoteData } from './QuoteContext';
+export { ComposerDropZone } from './ComposerDropZone';
+export type { ComposerDropZoneProps } from './ComposerDropZone';
+export { buildComposedMessage } from './build-composed-message';

package/dist/composer/useAppendToComposer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook to programmatically append text to the composer without sending it.
+ *
+ * Use `useSendMessage()` for workflow shortcuts or other UI that should
+ * immediately submit a prompt.
+ *
+ * Usage:
+ *   const append = useAppendToComposer();
+ *   append("some text to add");
+ *   append("quoted text", { replace: true }); // replaces existing text
+ */
+export declare function useAppendToComposer(): (text: string, opts?: {
+    replace?: boolean;
+}) => void;

package/dist/composer/useComposerAttachment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook for programmatic composer file attachment control.
+ *
+ * Usage:
+ *   const { addFile, addContent, clear } = useComposerAttachment();
+ *   addFile(fileObject);
+ *   addContent("data.csv", "col1,col2\n1,2");
+ *   clear();
+ */
+export declare function useComposerAttachment(): {
+    addFile: (file: File) => void;
+    addContent: (name: string, content: string) => void;
+    clear: () => void;
+};

package/dist/composer/useFileUpload.d.ts

@@ -0,0 +1,35 @@
+export interface UploadedAsset {
+    id: string;
+    title: string;
+    fileName: string;
+    fileSize: number;
+    mediaType: string;
+}
+export interface UploadProgress {
+    current: number;
+    total: number;
+    fileName: string;
+    /** 0–1 normalized progress for the current file */
+    percent: number;
+}
+export interface UseFileUploadReturn {
+    /** Upload one or more files to Athena. Returns the created asset(s). */
+    upload: (files: File[]) => Promise<UploadedAsset[]>;
+    /** Whether an upload is currently in progress. */
+    isUploading: boolean;
+    /** Upload progress info (null when idle). */
+    progress: UploadProgress | null;
+    /** Last upload error (null when no error). */
+    error: string | null;
+    /** Clear the error state. */
+    clearError: () => void;
+}
+/**
+ * Hook for uploading files to the Athena platform via the Athena upload endpoint.
+ * Files become Athena assets (documents, spreadsheets, PDFs, images, etc.).
+ *
+ * Usage:
+ *   const { upload, isUploading, progress, error } = useFileUpload();
+ *   const assets = await upload(fileList);
+ */
+export declare function useFileUpload(): UseFileUploadReturn;

package/dist/composer/useSendMessage.d.ts

@@ -0,0 +1,21 @@
+export interface SendMessageOptions {
+    /**
+     * Replace the current composer text before sending.
+     * Defaults to `true`.
+     */
+    replace?: boolean;
+}
+/**
+ * Hook to programmatically send a user message from anywhere inside AthenaProvider.
+ *
+ * This is intended for custom workflow buttons, sidebar shortcuts, or other UI
+ * that lives outside the AthenaChat thread tree. Unlike `aui.thread().append()`,
+ * this uses the provider-scoped composer runtime and does not depend on
+ * ThreadPrimitive context.
+ *
+ * Usage:
+ *   const sendMessage = useSendMessage();
+ *   await sendMessage("Run the quarterly workflow");
+ *   await sendMessage("Add this follow-up", { replace: false });
+ */
+export declare function useSendMessage(): (text: string, options?: SendMessageOptions) => Promise<void>;