@sarchauhan/chat 0.0.0-stage → 0.0.1

package/dist/index-DabpPX_p.d.ts

@@ -0,0 +1,177 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AgentWidgetProps, AgentToolPart, AgentWidgetPart, AgentArtifact, AgentSubagent } from '@sarchauhan/protocol';
+import { ComponentType, ReactNode, ReactElement } from 'react';
+
+type WidgetResponse = {
+    widgetId?: string;
+    name: string;
+    actionId?: string;
+    value: unknown;
+    label?: string;
+};
+type WidgetControls = {
+    widgetId?: string;
+    widgetName: string;
+    interactive: boolean;
+    disabled: boolean;
+    respond: (value: unknown, label?: string, actionId?: string) => Promise<void>;
+    respondWith: (response: Omit<WidgetResponse, "widgetId" | "name">) => Promise<void>;
+};
+type ChatWidgetProps<TProps extends AgentWidgetProps = AgentWidgetProps> = {
+    id?: string;
+    name: string;
+    props: TProps;
+    interactive?: boolean;
+    disabled?: boolean;
+    onRespond?: (response: WidgetResponse) => void | Promise<void>;
+};
+type ChatWidgetComponent<TProps extends AgentWidgetProps = AgentWidgetProps> = ComponentType<ChatWidgetProps<TProps>>;
+type WidgetComponentProps<TProps extends AgentWidgetProps = AgentWidgetProps> = TProps & {
+    widget: WidgetControls;
+};
+type WidgetValue<TProps extends AgentWidgetProps, TValue> = TValue | ((props: TProps, controls: WidgetControls) => TValue);
+type ChatWidgetDefinition<TProps extends AgentWidgetProps = AgentWidgetProps> = {
+    name: string;
+    component: ComponentType<WidgetComponentProps<TProps>>;
+    label?: WidgetValue<TProps, string>;
+    title?: WidgetValue<TProps, ReactNode>;
+    status?: WidgetValue<TProps, ReactNode>;
+    meta?: WidgetValue<TProps, ReactNode>;
+    className?: WidgetValue<TProps, string | undefined>;
+    shell?: boolean;
+};
+type ChatWidgetEntry<TProps extends AgentWidgetProps = AgentWidgetProps> = ChatWidgetComponent<TProps> | ChatWidgetDefinition<TProps>;
+type ChatWidgetRegistry = Record<string, ChatWidgetEntry>;
+type ChatWidgetInput = Array<ChatWidgetDefinition> | ChatWidgetRegistry;
+type DefineWidgetOptions<TProps extends AgentWidgetProps> = Pick<ChatWidgetDefinition<TProps>, "label" | "title" | "status" | "meta" | "className" | "shell">;
+declare function defineWidget<TProps extends AgentWidgetProps>(name: string, component: ComponentType<WidgetComponentProps<TProps>>, options?: DefineWidgetOptions<TProps>): ChatWidgetDefinition<TProps>;
+declare function createWidgetRegistry(widgets?: ChatWidgetInput): ChatWidgetRegistry;
+type WidgetContextValue = {
+    widgets: ChatWidgetRegistry;
+    respondToWidget: (response: WidgetResponse) => Promise<void>;
+    disabled: boolean;
+};
+type WidgetProviderProps = {
+    widgets?: ChatWidgetInput;
+    respondToWidget: (response: WidgetResponse) => Promise<void>;
+    disabled?: boolean;
+    children: ReactNode;
+};
+declare function WidgetProvider({ widgets, respondToWidget, disabled, children, }: WidgetProviderProps): react_jsx_runtime.JSX.Element;
+declare function useWidgets(): WidgetContextValue;
+
+type WidgetState = "running" | "complete" | "error" | "denied" | "approval";
+type ToolWidgetProps = {
+    state?: WidgetState;
+    error?: string;
+    className?: string;
+};
+type ReadFileWidgetProps = ToolWidgetProps & {
+    path: string;
+    content?: string;
+    startLine?: number;
+    language?: string;
+    maxLines?: number;
+};
+type PatchWidgetProps = ToolWidgetProps & {
+    path?: string;
+    diff?: string;
+    before?: string;
+    after?: string;
+    maxLines?: number;
+};
+type SearchResult = {
+    path: string;
+    line?: number;
+    text?: string;
+    title?: string;
+    url?: string;
+};
+type SearchWidgetProps = ToolWidgetProps & {
+    query: string;
+    results?: SearchResult[];
+    total?: number;
+    maxResults?: number;
+};
+type QuestionOption = {
+    label: string;
+    value: string;
+    description?: string;
+    recommended?: boolean;
+};
+type QuestionAnswer = {
+    values: string[];
+    text?: string;
+};
+type QuestionWidgetProps = {
+    prompt: string;
+    description?: string;
+    options?: Array<string | QuestionOption>;
+    multiple?: boolean;
+    allowCustom?: boolean;
+    disabled?: boolean;
+    onSubmit?: (answer: QuestionAnswer) => void | Promise<void>;
+    className?: string;
+};
+
+declare function ReadFileWidget({ path, content, startLine, language, maxLines, ...props }: ReadFileWidgetProps): react_jsx_runtime.JSX.Element;
+
+declare function PatchWidget({ path, diff: rawDiff, before, after, maxLines, ...props }: PatchWidgetProps): react_jsx_runtime.JSX.Element;
+
+declare function SearchWidget({ query, results, total, maxResults, ...props }: SearchWidgetProps): react_jsx_runtime.JSX.Element;
+
+declare function QuestionWidget({ prompt, description, options, multiple, allowCustom, disabled, onSubmit, className, }: QuestionWidgetProps): react_jsx_runtime.JSX.Element;
+
+/** Defaults are always available; a host registry can override any name. */
+declare const prebuiltWidgets: ChatWidgetRegistry;
+
+declare function computeToolState(part: AgentToolPart): WidgetState;
+declare function normalizeSearchResults(value: unknown): SearchResult[];
+/** Convert known tool payloads; unknown or incomplete formats retain the raw tool view. */
+declare function computeToolWidget(part: AgentToolPart): AgentWidgetPart | null;
+type DiffLine = {
+    kind: "add" | "remove" | "context" | "header";
+    text: string;
+    oldLine?: number;
+    newLine?: number;
+};
+/** Parse unified diffs (including multiple files) without counting file headers as edits. */
+declare function computeDiff(diff: string): {
+    lines: DiffLine[];
+    additions: number;
+    deletions: number;
+};
+declare function safeResultUrl(url?: string): string | undefined;
+/** Compute a unified replacement hunk with three context lines. Common edges stay out of the diff. */
+declare function computeTextDiff(before: string, after: string, path?: string): string;
+
+type ArtifactWidgetProps = {
+    artifact: AgentArtifact;
+    className?: string;
+};
+type ArtifactsWidgetProps = {
+    artifacts: AgentArtifact[];
+    className?: string;
+};
+/** Same-origin relative URLs, HTTP(S), blob URLs, and raster-image data URLs only. */
+declare function safeArtifactUrl(value?: string, image?: boolean): string | undefined;
+declare function formatArtifactSize(bytes?: number): string | undefined;
+declare function ArtifactWidget({ artifact, className }: ArtifactWidgetProps): react_jsx_runtime.JSX.Element;
+declare function ArtifactsWidget({ artifacts, className }: ArtifactsWidgetProps): react_jsx_runtime.JSX.Element;
+
+type SubagentWidgetProps = {
+    subagent: AgentSubagent;
+    className?: string;
+};
+declare function SubagentWidget({ subagent, className }: SubagentWidgetProps): react_jsx_runtime.JSX.Element;
+
+type ResponsiveDetailProps = {
+    title: string;
+    description?: string;
+    trigger: ReactElement;
+    children: ReactNode;
+};
+/** One accessible dialog; CSS changes its presentation to a bottom sheet below 640px. */
+declare function ResponsiveDetail({ title, description, trigger, children }: ResponsiveDetailProps): react_jsx_runtime.JSX.Element;
+
+export { ArtifactWidget as A, computeToolState as B, type ChatWidgetInput as C, type DefineWidgetOptions as D, computeToolWidget as E, createWidgetRegistry as F, defineWidget as G, formatArtifactSize as H, normalizeSearchResults as I, prebuiltWidgets as J, safeArtifactUrl as K, safeResultUrl as L, useWidgets as M, PatchWidget as P, type QuestionAnswer as Q, ReadFileWidget as R, type SearchResult as S, type ToolWidgetProps as T, type WidgetComponentProps as W, type ArtifactWidgetProps as a, ArtifactsWidget as b, type ArtifactsWidgetProps as c, type ChatWidgetComponent as d, type ChatWidgetDefinition as e, type ChatWidgetEntry as f, type ChatWidgetProps as g, type ChatWidgetRegistry as h, type DiffLine as i, type PatchWidgetProps as j, type QuestionOption as k, QuestionWidget as l, type QuestionWidgetProps as m, type ReadFileWidgetProps as n, ResponsiveDetail as o, type ResponsiveDetailProps as p, SearchWidget as q, type SearchWidgetProps as r, SubagentWidget as s, type SubagentWidgetProps as t, type WidgetControls as u, WidgetProvider as v, type WidgetResponse as w, type WidgetState as x, computeDiff as y, computeTextDiff as z };

package/dist/index.d.mts

@@ -0,0 +1,382 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, CSSProperties, Dispatch, HTMLAttributes, RefObject } from 'react';
+import * as _sarchauhan_adapter from '@sarchauhan/adapter';
+import { ChatAdapter, ChatMessage, ChatStatus, ChatThread } from '@sarchauhan/adapter';
+export { ChatAdapter, ChatMessage, ChatMessagePart, ChatRole, ChatStatus, ChatThread, EditMessageInput, SendMessageInput, defineAdapter } from '@sarchauhan/adapter';
+import { C as ChatWidgetInput } from './index-DabpPX_p.mjs';
+export { A as ArtifactWidget, a as ArtifactWidgetProps, b as ArtifactsWidget, c as ArtifactsWidgetProps, d as ChatWidgetComponent, e as ChatWidgetDefinition, f as ChatWidgetEntry, g as ChatWidgetProps, h as ChatWidgetRegistry, D as DefineWidgetOptions, i as DiffLine, P as PatchWidget, j as PatchWidgetProps, Q as QuestionAnswer, k as QuestionOption, l as QuestionWidget, m as QuestionWidgetProps, R as ReadFileWidget, n as ReadFileWidgetProps, o as ResponsiveDetail, p as ResponsiveDetailProps, S as SearchResult, q as SearchWidget, r as SearchWidgetProps, s as SubagentWidget, t as SubagentWidgetProps, T as ToolWidgetProps, W as WidgetComponentProps, u as WidgetControls, v as WidgetProvider, w as WidgetResponse, x as WidgetState, y as computeDiff, z as computeTextDiff, B as computeToolState, E as computeToolWidget, F as createWidgetRegistry, G as defineWidget, H as formatArtifactSize, I as normalizeSearchResults, J as prebuiltWidgets, K as safeArtifactUrl, L as safeResultUrl, M as useWidgets } from './index-DabpPX_p.mjs';
+import { AgentDataPart, AgentWidgetPart } from '@sarchauhan/protocol';
+export { AgentArtifact, AgentEvent, AgentMessage, AgentPart, AgentSubagent, AgentSubagentState, AgentToolPart, AgentWidgetPart, applyAgentEvent, createAgentMessageState, createArtifactData, createSubagentData, createWidgetData, normalizeAgentMessage, normalizeAgentParts, parseArtifact, parseSubagent, reduceAgentEvents } from '@sarchauhan/protocol';
+
+type ChatTheme = "light" | "dark" | "system";
+type ThemeContextValue = {
+    theme: ChatTheme;
+    resolvedTheme: "light" | "dark";
+    setTheme: (theme: ChatTheme) => void;
+    toggleTheme: () => void;
+};
+type ThemeProviderProps = {
+    children: ReactNode;
+    defaultTheme?: ChatTheme;
+    theme?: ChatTheme;
+    onThemeChange?: (theme: ChatTheme) => void;
+    storageKey?: string;
+};
+declare function ThemeProvider({ children, defaultTheme, theme: controlledTheme, onThemeChange, storageKey, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+
+type ComposerCollapsedVariant = "pill" | "circle";
+declare const ChatComposer: ({ showModelSelector, collapsedVariant, defaultExpanded, }: {
+    showModelSelector?: boolean;
+    /** Resting shape when the composer is empty and blurred. Default is the wide pill. */
+    collapsedVariant?: ComposerCollapsedVariant;
+    /** Open on the large composer. Used so a story can show the model picker without a click. */
+    defaultExpanded?: boolean;
+}) => react_jsx_runtime.JSX.Element;
+
+type BaseWidgetProps = {
+    label: string;
+    title: ReactNode;
+    status?: ReactNode;
+    meta?: ReactNode;
+    className?: string;
+    children?: ReactNode;
+};
+declare function BaseWidget({ label, title, status, meta, className, children, }: BaseWidgetProps): react_jsx_runtime.JSX.Element;
+
+type ChatProps = {
+    adapter: ChatAdapter;
+    className?: string;
+    defaultThreadId?: string;
+    defaultProvider?: string;
+    registryUrl?: string;
+    style?: CSSProperties;
+    /** Widget map or defineWidget(...) array. */
+    widgets?: ChatWidgetInput;
+    /** Controlled theme. Omit to manage theme internally. */
+    theme?: ChatTheme;
+    defaultTheme?: ChatTheme;
+    onThemeChange?: (theme: ChatTheme) => void;
+    showThemeToggle?: boolean;
+    showModelSelector?: boolean;
+    collapsedVariant?: ComposerCollapsedVariant;
+    defaultExpanded?: boolean;
+};
+declare function Chat({ adapter, className, defaultThreadId, defaultProvider, registryUrl, style, widgets, theme, defaultTheme, onThemeChange, showThemeToggle, showModelSelector, collapsedVariant, defaultExpanded, }: ChatProps): react_jsx_runtime.JSX.Element;
+
+declare enum ProviderId {
+    SYMPHONY = "symphony",
+    MOCK = "mock",
+    OPENAI = "openai",
+    GOOGLE = "google",
+    GEMINI = "gemini",
+    CLAUDE = "anthropic",
+    GROK = "grok",
+    OLLAMA = "ollama",
+    LOCAL = "local"
+}
+type RegistryModel = {
+    id: string;
+    label: string;
+    description?: string;
+    thinkingLevels?: string[];
+};
+type RegistryProvider = {
+    /** Known `ProviderId` values or a Symphony / custom registry id. */
+    id: string;
+    name?: string;
+    label: string;
+    logo?: string;
+    defaultModel: string;
+    models: RegistryModel[];
+};
+type RegistryConfig = {
+    defaultProviderId: string;
+    providers: RegistryProvider[];
+};
+declare const isProviderId: (value: unknown) => value is ProviderId;
+declare const parseRegistryConfig: (value: unknown) => RegistryConfig | undefined;
+type ChatReference = {
+    id: string;
+    text: string;
+};
+/** File part carried on the existing send payload. `url` is a data URL. */
+type ComposerFile = {
+    mediaType: string;
+    url: string;
+    filename?: string;
+};
+type ComposerAttachment = ComposerFile & {
+    id: string;
+    filename: string;
+};
+type SendMessage = (message: {
+    text: string;
+    files?: ComposerFile[];
+}, options?: {
+    body?: {
+        provider?: string;
+        model?: string;
+    };
+}) => Promise<void>;
+
+type ChatContextProviderProps = {
+    adapter: ChatAdapter;
+    children: ReactNode;
+    defaultProvider?: string;
+    defaultThreadId?: string;
+    registryUrl?: string;
+};
+declare function ChatContextProvider({ adapter, children, defaultProvider, defaultThreadId, registryUrl, }: ChatContextProviderProps): react_jsx_runtime.JSX.Element;
+
+type ComposerContextValue = {
+    input: string;
+    setInput: (value: string) => void;
+    references: ChatReference[];
+    addReference: (text: string) => void;
+    removeReference: (id: string) => void;
+    clearReferences: () => void;
+    attachments: ComposerAttachment[];
+    addFiles: (files: FileList | readonly File[]) => Promise<void>;
+    removeAttachment: (id: string) => void;
+    disabled: boolean;
+    canSend: boolean;
+    submitInput: () => Promise<void>;
+};
+declare function useComposer(): ComposerContextValue;
+
+type MessagesContextValue = {
+    messages: ChatMessage[];
+    status: ChatStatus;
+    isSending: boolean;
+    isWaitingForResponse: boolean;
+    sendMessage: SendMessage;
+    editAndResendMessage: (messageId: string, text: string) => Promise<void>;
+    stopResponse: () => void;
+};
+declare function useMessages(): MessagesContextValue;
+
+type ModelContextValue = {
+    registry: RegistryConfig;
+    provider: string;
+    model: string;
+    thinkingLevels: Record<string, string>;
+    getThinkingLevel: (providerId: string, modelId: string) => string | undefined;
+    setThinkingLevel: (providerId: string, modelId: string, level: string) => void;
+    setProvider: (provider: string, model?: string) => void;
+    setModel: (model: string) => void;
+    providerRef: React.MutableRefObject<string>;
+    modelRef: React.MutableRefObject<string>;
+    thinkingLevelsRef: React.MutableRefObject<Record<string, string>>;
+};
+declare function useModel(): ModelContextValue;
+
+type ThreadContextValue = {
+    threads: ChatThread[];
+    activeThreadId: string | null;
+    isLoadingThread: boolean;
+    activeThreadIdRef: React.MutableRefObject<string | null>;
+    setThreads: React.Dispatch<React.SetStateAction<ChatThread[]>>;
+    setIsLoadingThread: React.Dispatch<React.SetStateAction<boolean>>;
+    selectThread: (threadId: string) => Promise<void>;
+    createThread: () => Promise<void>;
+    deleteThread: (threadId: string) => Promise<void>;
+};
+declare function useThread(): ThreadContextValue;
+
+type CompatAction = {
+    type: "setInput";
+    data: {
+        input: string;
+    };
+} | {
+    type: "setProvider";
+    data: {
+        provider: string;
+        model?: string;
+    };
+} | {
+    type: "setModel";
+    data: {
+        model: string;
+    };
+} | {
+    type: "addReference";
+    data: {
+        text: string;
+    };
+} | {
+    type: "removeReference";
+    data: {
+        id: string;
+    };
+} | {
+    type: "clearReferences";
+};
+/**
+ * Compatibility facade over split contexts.
+ * Prefer useComposer / useMessages / useModel / useThread in UI components
+ * so typing and streaming do not share one render subscription.
+ */
+declare function useChat(): {
+    state: {
+        input: string;
+        provider: string;
+        model: string;
+        references: ChatReference[];
+        disabled: boolean;
+        sendDisabled: boolean;
+    };
+    dispatch: Dispatch<CompatAction>;
+    messages: _sarchauhan_adapter.ChatMessage[];
+    status: _sarchauhan_adapter.ChatStatus;
+    activeThreadId: string | null;
+    threads: _sarchauhan_adapter.ChatThread[];
+    isLoadingThread: boolean;
+    registry: RegistryConfig;
+    sendMessage: SendMessage;
+    submitInput: () => Promise<void>;
+    editAndResendMessage: (messageId: string, text: string) => Promise<void>;
+    stopResponse: () => void;
+    selectThread: (threadId: string) => Promise<void>;
+    createThread: () => Promise<void>;
+    deleteThread: (threadId: string) => Promise<void>;
+};
+
+declare const Message: () => react_jsx_runtime.JSX.Element;
+
+type MessageFeedbackProps = {
+    responseText: string;
+    onRegenerate: () => void;
+    canRegenerate: boolean;
+    disabled?: boolean;
+};
+declare const MessageFeedback: ({ responseText, onRegenerate, canRegenerate, disabled, }: MessageFeedbackProps) => react_jsx_runtime.JSX.Element | null;
+
+declare const MessageUsage: ({ parts }: {
+    parts: AgentDataPart[];
+}) => react_jsx_runtime.JSX.Element | null;
+
+declare const formatElapsed: (milliseconds: number, showTenths?: boolean) => string;
+declare const formatElapsedWords: (milliseconds: number) => string;
+type LoadingStateProps = {
+    label?: string;
+    compact?: boolean;
+};
+declare const LoadingState: ({ label, compact }: LoadingStateProps) => react_jsx_runtime.JSX.Element;
+
+type ThinkingBlockProps = {
+    isComplete: boolean;
+    elapsedMs?: number;
+    children?: ReactNode;
+};
+declare const ThinkingBlock: ({ isComplete, elapsedMs, children }: ThinkingBlockProps) => react_jsx_runtime.JSX.Element;
+
+type MessageContentProps = {
+    parts: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    isUser?: boolean;
+};
+declare const MessageContent: ({ parts, isUser }: MessageContentProps) => react_jsx_runtime.JSX.Element;
+
+declare function ThemeToggle({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function WidgetRenderer({ part, pending, }: {
+    part: AgentWidgetPart;
+    pending?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Public motion class names and data-attribute hooks from the
+ * transitions.dev recipes packaged with `@sarchauhan/chat`.
+ *
+ * Consumers should import these constants instead of hard-coding
+ * `t-*` strings so class names stay autocomplete-safe and typechecked.
+ */
+declare const motion: {
+    readonly textSwap: "t-text-swap";
+    readonly isExit: "is-exit";
+    readonly isEnterStart: "is-enter-start";
+    readonly iconSwap: "t-icon-swap";
+    readonly icon: "t-icon";
+    readonly successCheck: "t-success-check";
+    readonly dropdown: "t-dropdown";
+    readonly isOpen: "is-open";
+    readonly isClosing: "is-closing";
+    readonly inputWrap: "t-input-wrap";
+    readonly input: "t-input";
+    readonly errorMsg: "t-error-msg";
+    readonly isError: "is-error";
+    readonly isShaking: "is-shaking";
+};
+type MotionClass = (typeof motion)[keyof typeof motion];
+declare const iconSwapStates: readonly ["a", "b"];
+type IconSwapState = (typeof iconSwapStates)[number];
+declare const successCheckStates: readonly ["out", "in"];
+type SuccessCheckState = (typeof successCheckStates)[number];
+declare const dropdownOrigins: readonly ["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right"];
+type DropdownOrigin = (typeof dropdownOrigins)[number];
+declare const motionData: {
+    readonly state: "data-state";
+    readonly icon: "data-icon";
+    readonly origin: "data-origin";
+    readonly open: "data-open";
+};
+declare const dropdownPhases: readonly ["rest", "open", "closing"];
+type DropdownPhase = (typeof dropdownPhases)[number];
+
+declare const prefersReducedMotion: () => boolean;
+declare const motionRoot: (node?: Element | null) => Element | null;
+/** Read a duration custom property (ms) from `.chat-root`, with a numeric fallback. */
+declare const readDurationMs: (name: string, fallback: number, node?: Element | null) => number;
+type SwapTextOptions = {
+    onSwap?: () => void;
+};
+/**
+ * Three-phase text swap from transitions.dev (04-text-states-swap):
+ * exit → swap content → enter-start (no transition) → rest.
+ */
+declare const swapText: (el: HTMLElement, next: string, options?: SwapTextOptions) => number | undefined;
+declare const openDropdown: (el: HTMLElement) => void;
+declare const closeDropdown: (el: HTMLElement, onClosed?: () => void) => number;
+type TriggerErrorShakeOptions = {
+    /** Keep `.is-error` after the shake (persistent tool errors). Default: auto-revert. */
+    revert?: boolean;
+};
+/**
+ * Replay the error shake from a clean baseline (12-error-state-shake).
+ * `.is-error` and `.is-shaking` stay orthogonal so the shake can restart
+ * without flickering the error treatment.
+ */
+declare const triggerErrorShake: (wrap: HTMLElement, options?: TriggerErrorShakeOptions) => void;
+declare const clearErrorShake: (wrap: HTMLElement) => void;
+/** Measure an SVG path and set stroke-dasharray for the success-check draw. */
+declare const calibrateCheckPath: (path: SVGPathElement) => void;
+
+type TextSwapProps = {
+    text: string;
+} & Omit<HTMLAttributes<HTMLSpanElement>, "children">;
+/**
+ * Status-line text that swaps in place (transitions.dev text-states-swap).
+ * React keeps the outgoing string painted until the exit phase finishes.
+ */
+declare function TextSwap({ text, className, ...props }: TextSwapProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Keep a dropdown mounted through the close tween and apply the
+ * documented `.is-open` / `.is-closing` hooks (05-menu-dropdown).
+ *
+ * Mounts at rest (pre-scale, opacity 0), then adds `.is-open` on the
+ * next frame so the open transition actually plays.
+ */
+declare function useDropdownPresence(open: boolean, root?: Element | RefObject<Element | null> | null): {
+    readonly mounted: boolean;
+    readonly phase: "open" | "rest" | "closing";
+    readonly className: "is-open" | "is-closing" | undefined;
+};
+
+export { BaseWidget, type BaseWidgetProps, Chat, ChatComposer, ChatContextProvider, type ChatReference, type ChatTheme, ChatWidgetInput, type ComposerAttachment, type ComposerCollapsedVariant, type ComposerFile, type DropdownOrigin, type DropdownPhase, type IconSwapState, LoadingState, Message, MessageContent, MessageFeedback, MessageUsage, type MotionClass, ProviderId, type RegistryConfig, type RegistryModel, type RegistryProvider, type SendMessage, type SuccessCheckState, TextSwap, ThemeProvider, ThemeToggle, ThinkingBlock, WidgetRenderer, calibrateCheckPath, clearErrorShake, closeDropdown, dropdownOrigins, formatElapsed, formatElapsedWords, iconSwapStates, isProviderId, motion, motionData, motionRoot, openDropdown, parseRegistryConfig, prefersReducedMotion, readDurationMs, successCheckStates, swapText, triggerErrorShake, useChat, useComposer, useDropdownPresence, useMessages, useModel, useTheme, useThread };