@parallelworks/ui 0.18.0 → 0.19.0

package/dist/ai/components/ChatMessage.d.ts

@@ -0,0 +1,24 @@
+import type { ApprovalAnswerValue, AttachmentRef, ChatMessage as Message } from '../types.js';
+interface ChatMessageProps {
+    message: Message;
+    allMessages: Message[];
+    isStreaming?: boolean;
+    isEditing?: boolean;
+    showAuthor?: boolean | undefined;
+    currentUsername?: string | undefined;
+    attachmentDownloadUrl?: ((id: string) => string) | undefined;
+    onOpenAttachment?: ((attachment: AttachmentRef) => void) | undefined;
+    onNavigateBranch?: ((messageId: string) => void) | undefined;
+    onEdit?: ((messageId: string) => void) | undefined;
+    onSaveEdit?: ((messageId: string, content: string) => void) | undefined;
+    onCancelEdit?: (() => void) | undefined;
+    onRegenerate?: ((messageId: string) => void) | undefined;
+    onRetry?: ((messageId: string) => void) | undefined;
+    onOpenReasoning?: ((reasoning: string, duration: number | null) => void) | undefined;
+    onApprovalAnswer?: ((id: string, answer: ApprovalAnswerValue) => void) | undefined;
+    /** Drops the row's horizontal padding, for hosts that constrain the column themselves. */
+    flush?: boolean | undefined;
+}
+declare function ChatMessage({ message, allMessages, isStreaming, isEditing, showAuthor, currentUsername, attachmentDownloadUrl, onOpenAttachment, onNavigateBranch, onEdit, onSaveEdit, onCancelEdit, onRegenerate, onRetry, onOpenReasoning, onApprovalAnswer, flush, }: ChatMessageProps): import("react").JSX.Element | null;
+declare const _default: import("react").MemoExoticComponent<typeof ChatMessage>;
+export default _default;

package/dist/ai/components/ChatMessageList.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from 'react';
+import type { ApprovalAnswerValue, ChatMessage as Message } from '../types.js';
+interface ChatMessageListProps {
+    messages: Message[];
+    allMessages: Message[];
+    streamingMessage?: Message | null;
+    queuedMessages?: Message[];
+    onRemoveQueued?: (id: string) => void;
+    editingMessageId?: string | null | undefined;
+    showAuthor?: boolean;
+    currentUsername?: string;
+    onNavigateBranch?: (messageId: string) => void;
+    onEditMessage?: ((messageId: string) => void) | undefined;
+    onSaveEdit?: (messageId: string, content: string) => void;
+    onCancelEdit?: () => void;
+    onRegenerateMessage?: ((messageId: string) => void) | undefined;
+    onRetryMessage?: ((messageId: string) => void) | undefined;
+    onOpenReasoning?: (reasoning: string, duration: number | null) => void;
+    onApprovalAnswer?: (id: string, answer: ApprovalAnswerValue) => void;
+    inputElement?: ReactNode;
+    /** Whether a turn is in flight, when the host tracks that itself rather
+     *  than streaming through the provider. */
+    isStreaming?: boolean;
+    /** Rows without their own side padding, for a host that pads the column. */
+    flush?: boolean;
+    /** Names the list as a live log for assistive technology. */
+    label?: string;
+    /** Rendered after the last message, inside the scrolling column. */
+    footer?: ReactNode;
+    /** Off for a host that shows the turn's activity elsewhere, so the wait
+     *  for the first frame is not announced twice. */
+    workingIndicator?: boolean;
+}
+export default function ChatMessageList({ messages, allMessages, streamingMessage, queuedMessages, onRemoveQueued, editingMessageId, showAuthor, currentUsername, onNavigateBranch, onEditMessage, onSaveEdit, onCancelEdit, onRegenerateMessage, onRetryMessage, onOpenReasoning, onApprovalAnswer, inputElement, isStreaming: isStreamingProp, flush, label, footer, workingIndicator, }: ChatMessageListProps): import("react").JSX.Element;
+export {};

package/dist/ai/components/ChatSidebar.d.ts

@@ -0,0 +1,5 @@
+export type ConversationGroupKey = 'groupToday' | 'groupYesterday' | 'groupThisWeek' | 'groupThisMonth' | 'groupOlder';
+export default function ChatSidebar({ actions, }: {
+    /** False when the host's page header carries new chat, attachments and search. */
+    actions?: boolean;
+}): import("react").JSX.Element;

package/dist/ai/components/ChatThread.d.ts

@@ -0,0 +1,3 @@
+export default function ChatThread({ conversationId }: {
+    conversationId: string;
+}): import("react").JSX.Element;

package/dist/ai/components/ComposerChrome.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+/** Where the turn runs, sitting above the composer the way the terminal shows
+ *  it: the machine, the workspace, and whatever else names the place. */
+export declare function ComposerContext({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** What the turn runs as, sitting under the composer: the surface's own
+ *  controls on the left, the model on the right, both reading as plain text. */
+export declare function ComposerSettings({ left, children }: {
+    left?: ReactNode;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/** The two selectors every surface carries, bare so they read as text beside
+ *  whatever the surface puts next to them. */
+export declare function ComposerControls({ targetSession }: {
+    targetSession?: string | null | undefined;
+}): import("react").JSX.Element;
+export declare function ConnectToolsLink(): import("react").JSX.Element | null;

package/dist/ai/components/ComposerFrame.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+/** The column a composer sits in: notices above it, what the agent is doing
+ *  right now, a row of chips saying where the message goes, the box itself,
+ *  and a row of settings under it with the model and allocation on the right. */
+export default function ComposerFrame({ notices, activity, above, belowLeft, belowRight, hint, className, children, }: {
+    notices?: ReactNode;
+    /** Sits where a terminal's spinner line would, just above the box. */
+    activity?: ReactNode;
+    above?: ReactNode;
+    belowLeft?: ReactNode;
+    /** Defaults to the model and allocation pickers. */
+    belowRight?: ReactNode;
+    hint?: string | undefined;
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/ai/components/DragOverlay.d.ts

@@ -0,0 +1,5 @@
+interface DragOverlayProps {
+    className?: string;
+}
+export default function DragOverlay({ className }: DragOverlayProps): import("react").JSX.Element;
+export {};

package/dist/ai/components/ModelSelector.d.ts

@@ -0,0 +1,6 @@
+export declare function getProviderKeyFromModelId(modelId: string): string;
+export default function ModelSelector({ targetSession, variant, }: {
+    targetSession?: string | null | undefined;
+    /** 'bare' drops the border and the icon, for a toolbar that reads as text. */
+    variant?: 'default' | 'bare';
+}): import("react").JSX.Element;

package/dist/ai/components/ShareDialog.d.ts

@@ -0,0 +1,11 @@
+interface ShareDialogProps {
+    conversationId: string;
+    isOpen: boolean;
+    onClose: () => void;
+}
+export default function ShareDialog({ conversationId, isOpen, onClose }: ShareDialogProps): import("react").JSX.Element | null;
+export declare function ShareButton({ conversationId, disabled, }: {
+    conversationId: string;
+    disabled?: boolean;
+}): import("react").JSX.Element | null;
+export {};

package/dist/ai/components/SlashMenu.d.ts

@@ -0,0 +1,28 @@
+import { type KeyboardEvent } from 'react';
+export interface SlashCommandOption {
+    name: string;
+    description?: string | undefined;
+    usage?: string | undefined;
+}
+export interface SlashMenuConfig {
+    commands: SlashCommandOption[];
+    /** Names the listbox for assistive tech. */
+    label: string;
+    /** Called when the input first reads as a command, so a host can load the list lazily. */
+    onOpen?: (() => void) | undefined;
+}
+export declare function slashMatches(input: string, commands: SlashCommandOption[]): SlashCommandOption[];
+/** The palette's open state and keys; the caller owns the input. */
+export declare function useSlashMenu(input: string, config: SlashMenuConfig | undefined, setInput: (value: string) => void): {
+    open: boolean;
+    matches: SlashCommandOption[];
+    active: number;
+    choose: (name: string) => void;
+    handleKey: (e: KeyboardEvent<HTMLTextAreaElement>) => boolean;
+};
+export declare function SlashMenu({ label, matches, active, onChoose, }: {
+    label: string;
+    matches: SlashCommandOption[];
+    active: number;
+    onChoose: (name: string) => void;
+}): import("react").JSX.Element;

package/dist/ai/components/agent/ActivityLine.d.ts

@@ -0,0 +1,21 @@
+/** The agent status words: one is picked per turn and held until it ends. */
+export declare const activityWords: readonly ['Thinking', 'Cogitating', 'Pondering', 'Percolating', 'Ruminating', 'Noodling', 'Conjuring', 'Simmering', 'Marinating', 'Tinkering', 'Scheming', 'Brewing', 'Wrangling', 'Finagling', 'Spelunking', 'Puttering', 'Composing', 'Synthesizing', 'Deliberating', 'Mulling', 'Contemplating', 'Vibing', 'Whittling', 'Concocting', 'Formulating', 'Hatching', 'Herding', 'Ideating', 'Manifesting', 'Moseying', 'Musing', 'Percussing', 'Reticulating', 'Schlepping', 'Stewing', 'Transmuting', 'Wibbling', 'Crunching', 'Forging', 'Cooking'];
+export declare function randomActivityWord(): string;
+/** Elapsed run time the way an agent status line prints it: 45s, 2m13s,
+ *  1h2m3s. */
+export declare function formatElapsed(seconds: number): string;
+/** Token counts the way an agent status line prints them: 512, 1.2k, 3.4M. */
+export declare function compactCount(n: number): string;
+/** The terminal's "it's working" line for a running turn: spinner, status
+ *  word, how long the turn has run, its token counts so far, and a way to
+ *  stop it. */
+export default function ActivityLine({ startedAt, inputTokens, outputTokens, onStop, stopping, word, testId, }: {
+    startedAt: string | null | undefined;
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    onStop?: (() => void) | undefined;
+    stopping?: boolean;
+    /** Replaces the turn's word, the way a running hook names itself. */
+    word?: string | undefined;
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/ai/components/agent/AgentMessageParts.d.ts

@@ -0,0 +1,54 @@
+import { type PartRendererProps } from '../../core/config.js';
+import type { ApprovalPart, MessagePart, NoticePart, ReasoningPart, SubagentPart, TodoSnapshotPart, ToolCallPart } from '../../types.js';
+export declare function ToolCallBlock({ part }: {
+    part: ToolCallPart;
+}): import("react").JSX.Element;
+/** Drawn the way the TUI draws a delegated Task: a tool-shaped header
+ *  `Task(description)`, and under it the latest action while running or
+ *  `Done (summary)` once finished. Expanding shows the whole activity feed. */
+export declare function SubagentCard({ part }: {
+    part: SubagentPart;
+}): import("react").JSX.Element;
+export declare function ApprovalBlock({ part, onApprovalAnswer, }: {
+    part: ApprovalPart;
+    onApprovalAnswer?: PartRendererProps['onApprovalAnswer'];
+}): import("react").JSX.Element;
+export declare function TodoSnapshotBlock({ part }: {
+    part: TodoSnapshotPart;
+}): import("react").JSX.Element;
+export declare function NoticeBlock({ part }: {
+    part: NoticePart;
+}): import("react").JSX.Element;
+/** The TUI's thought: the body shows while it streams, then folds to its
+ *  label and opens on request. The composer's activity line carries the
+ *  live signal, so nothing here animates. */
+export declare function ReasoningBlock({ part, isStreaming, }: {
+    part: ReasoningPart;
+    isStreaming?: boolean;
+}): import("react").JSX.Element;
+type RunMember = {
+    part: ToolCallPart | ReasoningPart;
+    index: number;
+};
+type RenderItem = {
+    kind: 'single';
+    part: MessagePart;
+    index: number;
+} | {
+    kind: 'reasoning';
+    parts: ReasoningPart[];
+    index: number;
+} | {
+    kind: 'rollup';
+    members: RunMember[];
+};
+/** Two thoughts with nothing visible between them read as one, not as a
+ *  stack of identical lines. */
+export declare function mergeReasoning(parts: ReasoningPart[]): ReasoningPart;
+export declare function buildRenderItems(parts: MessagePart[]): RenderItem[];
+export default function AgentMessageParts({ message, isStreaming, onApprovalAnswer, }: {
+    message: PartRendererProps['message'];
+    isStreaming?: boolean;
+    onApprovalAnswer?: PartRendererProps['onApprovalAnswer'];
+}): import("react").JSX.Element;
+export {};

package/dist/ai/components/agent/PermissionPicker.d.ts

@@ -0,0 +1,11 @@
+import { type PermissionMode } from '../../agent/permissions.js';
+/** What the agent may do, as a toolbar chip: the choices stop at the machine's
+ *  ceiling, and a mode set elsewhere (plan, or one past the ceiling) still
+ *  shows by name. */
+export default function PermissionPicker({ mode, onPick, ceiling, disabled, }: {
+    mode: string | undefined;
+    onPick: (mode: PermissionMode) => void;
+    /** The machine's remoteMaxPermissionMode; unknown offers the daemon default. */
+    ceiling: string | undefined;
+    disabled?: boolean;
+}): import("react").JSX.Element;

package/dist/ai/components/attachmentKeys.d.ts

@@ -0,0 +1,4 @@
+import type { AttachmentPage } from '../adapter/types.js';
+export declare const ATTACHMENTS_PAGE_SIZE = 24;
+export declare function attachmentsPageKey(index: number, previousPage: AttachmentPage | null): [string, string] | null;
+export declare const ATTACHMENTS_INFINITE_KEY: string;

package/dist/ai/core/ChatProvider.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from 'react';
+import type { ChatAdapter } from '../adapter/types.js';
+import type { ChatModel, ChatNavigation, ChatNotify, ChatUser, Conversation, ConversationSummary, ChatMessage as Message, MessagePart, ProviderInfo, UnreachableSession } from '../types.js';
+import { type ChatUIConfig } from './config.js';
+interface ChatContextValue {
+    adapter: ChatAdapter;
+    currentUser: ChatUser;
+    navigation: ChatNavigation;
+    notify: ChatNotify;
+    activeConversationId: string | null;
+    conversations: ConversationSummary[];
+    currentConversation: Conversation | null;
+    providers: ProviderInfo[];
+    models: ChatModel[];
+    unreachableSessions: UnreachableSession[];
+    selectedProvider: string | null;
+    isSelectedModelAvailable: boolean;
+    selectedAllocation: string | null;
+    isLoading: boolean;
+    isLoadingConversation: boolean;
+    isLoadingModels: boolean;
+    hasLoadedModels: boolean;
+    modelsError: string | null;
+    isStreaming: boolean;
+    isThinking: boolean;
+    streamingContent: string;
+    streamingReasoning: string;
+    streamingParts: MessagePart[];
+    thinkingStartTime: number | null;
+    sidebarCollapsed: boolean;
+    queuedMessages: Message[];
+    loadConversations: () => Promise<void>;
+    loadConversation: (id: string) => Promise<void>;
+    loadProviders: () => Promise<void>;
+    refreshProviders: () => Promise<void>;
+    refreshModels: () => Promise<void>;
+    createConversation: (title?: string) => Promise<string | null>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    sendMessage: (content: string, attachmentIds?: string[], parentId?: string, attachmentMeta?: Record<string, {
+        filename: string;
+        contentType: string;
+        size: number;
+    }>) => Promise<boolean>;
+    retryMessage: (messageId: string) => Promise<boolean>;
+    setSelectedProvider: (providerId: string | null) => void;
+    setSelectedAllocation: (allocation: string | null) => void;
+    stopStreaming: () => void;
+    removeQueuedMessage: (id: string) => void;
+    flushQueuedMessages: () => void;
+    toggleSidebar: () => void;
+    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
+    navigateToBranch: (messageId: string) => void;
+    clearCurrentConversation: () => void;
+}
+export declare function useChat(): ChatContextValue;
+export interface ChatProviderProps {
+    adapter: ChatAdapter;
+    currentUser: ChatUser;
+    navigation: ChatNavigation;
+    notify: ChatNotify;
+    activeConversationId?: string | null;
+    config?: ChatUIConfig;
+    children: ReactNode;
+}
+export declare function ChatProvider({ adapter, currentUser, navigation, notify, activeConversationId, config, children, }: ChatProviderProps): import("react").JSX.Element;
+export {};

package/dist/ai/core/KeyboardShortcutsProvider.d.ts

@@ -0,0 +1,5 @@
+interface KeyboardShortcutsProviderProps {
+    children: React.ReactNode;
+}
+export declare function KeyboardShortcutsProvider({ children }: KeyboardShortcutsProviderProps): import("react").JSX.Element;
+export {};

package/dist/ai/core/chatReducer.d.ts

@@ -0,0 +1,114 @@
+import type { PartDelta } from '../adapter/types.js';
+import type { ChatMessage, ChatModel, Conversation, ConversationSummary, MessagePart, ProviderInfo, UnreachableSession } from '../types.js';
+export interface ChatState {
+    conversations: ConversationSummary[];
+    currentConversation: Conversation | null;
+    providers: ProviderInfo[];
+    models: ChatModel[];
+    unreachableSessions: UnreachableSession[];
+    selectedProvider: string | null;
+    selectedAllocation: string | null;
+    isLoading: boolean;
+    isLoadingConversation: boolean;
+    isLoadingModels: boolean;
+    hasLoadedModels: boolean;
+    modelsError: string | null;
+    isStreaming: boolean;
+    isThinking: boolean;
+    streamingContent: string;
+    streamingReasoning: string;
+    streamingParts: MessagePart[];
+    thinkingStartTime: number | null;
+    sidebarCollapsed: boolean;
+    queuedMessages: ChatMessage[];
+}
+export type ChatAction = {
+    type: 'SET_CONVERSATIONS';
+    conversations: ConversationSummary[];
+} | {
+    type: 'SET_CURRENT_CONVERSATION';
+    conversation: Conversation | null;
+} | {
+    type: 'UPDATE_CURRENT_CONVERSATION_TITLE';
+    title: string;
+} | {
+    type: 'SET_PROVIDERS';
+    providers: ProviderInfo[];
+} | {
+    type: 'SET_MODELS';
+    models: ChatModel[];
+    unreachableSessions?: UnreachableSession[];
+} | {
+    type: 'SET_SELECTED_PROVIDER';
+    providerId: string | null;
+} | {
+    type: 'SET_SELECTED_ALLOCATION';
+    allocation: string | null;
+} | {
+    type: 'SET_LOADING';
+    isLoading: boolean;
+} | {
+    type: 'SET_LOADING_MODELS';
+    isLoadingModels: boolean;
+} | {
+    type: 'SET_MODELS_ERROR';
+    error: string | null;
+} | {
+    type: 'SET_STREAMING';
+    isStreaming: boolean;
+    conversationId?: string;
+} | {
+    type: 'SET_THINKING';
+    isThinking: boolean;
+} | {
+    type: 'APPEND_STREAMING_CONTENT';
+    content: string;
+    conversationId: string;
+} | {
+    type: 'APPEND_STREAMING_REASONING';
+    reasoning: string;
+    conversationId: string;
+} | {
+    type: 'APPLY_STREAMING_PART';
+    delta: PartDelta;
+    conversationId: string;
+} | {
+    type: 'CLEAR_STREAMING_CONTENT';
+    conversationId?: string;
+} | {
+    type: 'ADD_MESSAGE';
+    message: ChatMessage;
+    conversationId: string;
+} | {
+    type: 'UPDATE_MESSAGE';
+    messageId: string;
+    updates: Partial<ChatMessage>;
+    conversationId: string;
+} | {
+    type: 'TOGGLE_SIDEBAR';
+} | {
+    type: 'ADD_CONVERSATION';
+    conversation: ConversationSummary;
+} | {
+    type: 'REMOVE_CONVERSATION';
+    conversationId: string;
+} | {
+    type: 'SET_LOADING_CONVERSATION';
+    isLoadingConversation: boolean;
+} | {
+    type: 'RESTORE_BACKGROUND_STREAM';
+    content: string;
+    reasoning: string;
+    parts?: MessagePart[];
+} | {
+    type: 'ADD_QUEUED_MESSAGE';
+    message: ChatMessage;
+    conversationId?: string;
+} | {
+    type: 'REMOVE_QUEUED_MESSAGE';
+    id: string;
+} | {
+    type: 'CLEAR_QUEUED_MESSAGES';
+};
+export declare const initialState: ChatState;
+export declare function chatReducer(state: ChatState, action: ChatAction): ChatState;

package/dist/ai/core/config.d.ts

@@ -0,0 +1,47 @@
+import { type ComponentType, type MouseEventHandler, type ReactNode } from 'react';
+import type { Components } from 'streamdown';
+import { type ChatStrings } from '../strings.js';
+import type { ApprovalAnswerValue, ChatLinkTarget, ChatMessage, CspKind, MessagePart, MessagePartKind } from '../types.js';
+export interface PartRendererProps {
+    part: MessagePart;
+    message: ChatMessage;
+    isStreaming?: boolean;
+    onApprovalAnswer?: (id: string, answer: ApprovalAnswerValue) => void;
+}
+export interface ChatLinkProps {
+    target: ChatLinkTarget;
+    className?: string;
+    title?: string;
+    onClick?: MouseEventHandler;
+    children: ReactNode;
+}
+export interface ChatUIConfig {
+    LinkComponent?: ComponentType<ChatLinkProps>;
+    extraLinks?: {
+        connectTools?: string;
+        manageProviders?: string;
+        addProvider?: string;
+        providerSettings?: (owner: string, name: string) => string;
+    };
+    slots?: {
+        composerUsage?: ReactNode;
+        providerIcon?: (cspKind: CspKind, className?: string) => ReactNode;
+        partRenderers?: Partial<Record<MessagePartKind, ComponentType<PartRendererProps>>>;
+    };
+    strings?: {
+        [S in keyof ChatStrings]?: Partial<ChatStrings[S]>;
+    };
+    markdownComponents?: Components;
+    suggestedPrompts?: string[];
+}
+export interface ResolvedChatConfig {
+    LinkComponent: ComponentType<ChatLinkProps>;
+    extraLinks: NonNullable<ChatUIConfig['extraLinks']>;
+    slots: NonNullable<ChatUIConfig['slots']>;
+    strings: ChatStrings;
+    markdownComponents?: Components;
+    suggestedPrompts?: string[];
+}
+export declare function resolveChatConfig(config?: ChatUIConfig): ResolvedChatConfig;
+export declare const ChatConfigProvider: import("react").Provider<ResolvedChatConfig>;
+export declare function useChatConfig(): ResolvedChatConfig;

package/dist/ai/core/events.d.ts

@@ -0,0 +1 @@
+export declare const FOCUS_SIDEBAR_SEARCH_EVENT = "aichat:focus-sidebar-search";

package/dist/ai/core/exportConversation.d.ts

@@ -0,0 +1,4 @@
+import type { Conversation } from '../types.js';
+export declare function conversationToMarkdown(conversation: Conversation): string;
+export declare function exportFilename(title?: string | null): string;
+export declare function downloadText(filename: string, text: string): void;

package/dist/ai/core/greeting.d.ts

@@ -0,0 +1,3 @@
+export declare function getGreeting(user: {
+    name?: string | null;
+} | null): string;

package/dist/ai/core/parts.d.ts

@@ -0,0 +1,11 @@
+import type { PartDelta } from '../adapter/types.js';
+import type { MessagePart } from '../types.js';
+/** Fold one streamed PartDelta into a parts timeline. Pure: returns a new
+ *  array, leaving the input untouched, so it works for both reducer state
+ *  and the provider's local accumulation. Unknown target ids are dropped
+ *  rather than invented — an end without a start has nothing to render. */
+export declare function applyPartDelta(parts: MessagePart[], delta: PartDelta): MessagePart[];
+/** A turn can end (completed or stopped) with tool calls still marked
+ *  running — the transport died before their tool_end arrived. A stored
+ *  message must not spin forever, so close them out as interrupted. */
+export declare function finalizeParts(parts: MessagePart[]): MessagePart[];

package/dist/ai/core/useDragDrop.d.ts

@@ -0,0 +1,14 @@
+import { type DragEvent } from 'react';
+interface UseDragDropOptions {
+    onFilesDropped: (files: FileList) => void;
+}
+export default function useDragDrop({ onFilesDropped }: UseDragDropOptions): {
+    isDragging: boolean;
+    dragHandlers: {
+        onDragEnter: (e: DragEvent) => void;
+        onDragLeave: (e: DragEvent) => void;
+        onDragOver: (e: DragEvent) => void;
+        onDrop: (e: DragEvent) => void;
+    };
+};
+export {};

package/dist/ai/core/useKeyboardShortcuts.d.ts

@@ -0,0 +1,12 @@
+import type { ChatMessage } from '../types.js';
+interface UseKeyboardShortcutsOptions {
+    enabled?: boolean;
+}
+export declare function useKeyboardShortcuts(options?: UseKeyboardShortcutsOptions): {
+    getLastUserMessage: () => ChatMessage | null;
+    getLastAssistantMessage: () => string | null | undefined;
+    handleNewConversation: () => void;
+    handleCopyLastResponse: () => Promise<void>;
+    handleStopGeneration: () => void;
+};
+export {};

package/dist/ai/core/useSSEStream.d.ts

@@ -0,0 +1,34 @@
+import type { MessagePart } from '../types.js';
+import type { ChatAction } from './chatReducer.js';
+interface BackgroundStream {
+    content: string;
+    reasoning: string;
+    parts: MessagePart[];
+    messageId: string | null;
+    isActive: boolean;
+}
+interface UseSSEStreamResult {
+    /** Feed a chunk of text into the animation buffer */
+    onStreamingChunk: (chunk: string) => void;
+    /** Start the animation loop for a conversation */
+    startStreaming: (conversationId: string) => void;
+    /** Stop the animation loop, flush remaining content */
+    stopAnimationLoop: () => {
+        unrevealed: string;
+        conversationId: string | null;
+    };
+    /** Reset all animation refs (used when navigating away) */
+    resetAnimationRefs: () => void;
+    /** Ref to the target content buffer */
+    targetStreamContentRef: React.RefObject<string>;
+    /** Ref tracking whether streaming is active */
+    streamActiveRef: React.MutableRefObject<boolean>;
+    /** Ref tracking which conversation is being streamed */
+    streamingConversationIdRef: React.MutableRefObject<string | null>;
+    /** Per-conversation background stream storage */
+    backgroundStreamsRef: React.MutableRefObject<Map<string, BackgroundStream>>;
+    /** AbortController ref for cancelling fetch requests */
+    abortControllerRef: React.MutableRefObject<AbortController | null>;
+}
+export declare function useSSEStream(dispatch: React.Dispatch<ChatAction>): UseSSEStreamResult;
+export {};

package/dist/ai/index.d.ts

@@ -0,0 +1,40 @@
+export { durationToAbsHumanDuration } from '../duration.js';
+export * from './adapter/types.js';
+export * from './agent/index.js';
+export { default as AllocationSelector } from './components/AllocationSelector.js';
+export { default as AttachmentManager } from './components/AttachmentManager.js';
+export { type Attachment, type AttachmentUploadHandle, default as AttachmentUpload, } from './components/AttachmentUpload.js';
+export { compactCount, default as ActivityLine, formatElapsed, } from './components/agent/ActivityLine.js';
+export { ApprovalBlock, default as AgentMessageParts, } from './components/agent/AgentMessageParts.js';
+export { default as PermissionPicker } from './components/agent/PermissionPicker.js';
+export { default as BlockedGroupBanner } from './components/BlockedGroupBanner.js';
+export { default as BranchNavigator } from './components/BranchNavigator.js';
+export { default as ChatEmptyState } from './components/ChatEmptyState.js';
+export { type ChatInputHandle, default as ChatInput, } from './components/ChatInput.js';
+export { default as ChatLayout } from './components/ChatLayout.js';
+export { default as ChatMessageView } from './components/ChatMessage.js';
+export { default as ChatMessageList } from './components/ChatMessageList.js';
+export { default as ChatSidebar } from './components/ChatSidebar.js';
+export { default as ChatThread } from './components/ChatThread.js';
+export { ComposerContext, ComposerControls, ComposerSettings, ConnectToolsLink, } from './components/ComposerChrome.js';
+export { default as ComposerFrame } from './components/ComposerFrame.js';
+export { default as DragOverlay } from './components/DragOverlay.js';
+export { default as ModelSelector, getProviderKeyFromModelId, } from './components/ModelSelector.js';
+export { default as ShareDialog, ShareButton, } from './components/ShareDialog.js';
+export { type SlashCommandOption, type SlashMenuConfig, slashMatches, } from './components/SlashMenu.js';
+export { ChatProvider, type ChatProviderProps, useChat, } from './core/ChatProvider.js';
+export { type ChatAction, type ChatState, chatReducer, initialState, } from './core/chatReducer.js';
+export type { PartRendererProps } from './core/config.js';
+export { type ChatLinkProps, type ChatUIConfig, resolveChatConfig, useChatConfig, } from './core/config.js';
+export { FOCUS_SIDEBAR_SEARCH_EVENT } from './core/events.js';
+export { getGreeting } from './core/greeting.js';
+export { KeyboardShortcutsProvider } from './core/KeyboardShortcutsProvider.js';
+export { applyPartDelta, finalizeParts } from './core/parts.js';
+export { default as useDragDrop } from './core/useDragDrop.js';
+export { useKeyboardShortcuts } from './core/useKeyboardShortcuts.js';
+export { type ChatStrings, defaultChatStrings } from './strings.js';
+export * from './types.js';
+export { type DropdownOption, default as Dropdown } from './ui/Dropdown.js';
+export { NoticeBar, NoticeCard, type NoticeTone } from './ui/Notice.js';
+export { RenameDialog, type RowDialogStrings, SidebarGroupHeading, SidebarPanel, SidebarRailItem, SidebarRow, SidebarToggle, useRowDialogs, } from './ui/sidebar.js';
+export { formatFileSize, isMac, isOrgModel } from './utils.js';