@sarchauhan/chat 0.0.0-stage → 0.0.1

package/dist/index.d.ts

@@ -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.js';
+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.js';
+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 };