teodor-new-chat-ui 1.2.6 → 1.2.8

package/dist/components/chat/ChatApp.d.ts

@@ -1,8 +1,27 @@
-interface ChatAppProps {
-    apiBaseUrl?: string;
-    enableUrlSync?: boolean;
-    layout?: 'sidebar' | 'tabs' | 'split';
+/**
+ * Chat App - Complete chat application with sidebar layout
+ * Combines all chat components into a ready-to-use chat interface
+ */
+import { ChatProviderProps } from './ChatProvider';
+import { ApiConfig } from '@/types/api';
+export interface ChatAppProps extends Omit<ChatProviderProps, 'children'> {
+    layout?: 'sidebar' | 'fullscreen' | 'tabs';
+    showThreads?: boolean;
     className?: string;
+    customStyles?: {
+        container?: string;
+        sidebar?: string;
+        chatArea?: string;
+    };
 }
-export declare function ChatApp({ apiBaseUrl, enableUrlSync, layout, className }: ChatAppProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function ChatApp({ layout, showThreads, className, customStyles, ...providerProps }: ChatAppProps): import("react/jsx-runtime").JSX.Element;
+export interface SimpleChatProps {
+    apiConfig: ApiConfig;
+    className?: string;
+    onError?: (error: string) => void;
+}
+export declare function SimpleChat({ apiConfig, className, onError }: SimpleChatProps): import("react/jsx-runtime").JSX.Element;
+export * from './ChatProvider';
+export * from './ChatInterface';
+export * from './ThreadManager';
+export * from './MessageComponent';

package/dist/components/chat/ChatInterface.d.ts

@@ -1,10 +1,21 @@
-interface ChatInterfaceProps {
+/**
+ * Chat Interface - Clean, exportable chat UI component
+ * Designed for use across multiple applications with customizable styling
+ */
+export interface ChatInterfaceProps {
     className?: string;
     placeholder?: string;
     autoFocus?: boolean;
-    showBranches?: boolean;
     maxHeight?: string;
-    enableInputFieldEditing?: boolean;
+    enableFileUpload?: boolean;
+    enableMessageEditing?: boolean;
+    customStyles?: {
+        container?: string;
+        messagesArea?: string;
+        inputArea?: string;
+        sendButton?: string;
+    };
+    onMessageSent?: (message: string) => void;
+    onError?: (error: string) => void;
 }
-export declare function ChatInterface({ className, placeholder, autoFocus, showBranches, maxHeight, enableInputFieldEditing }: ChatInterfaceProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function ChatInterface({ className, placeholder, autoFocus, maxHeight, enableFileUpload, enableMessageEditing, customStyles, onMessageSent, onError }: ChatInterfaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ChatProvider.d.ts

@@ -1,93 +1,49 @@
-import React from 'react';
-export interface Message {
-    id?: string;
-    role: "human" | "ai" | "tool";
-    content: string | any;
-    timestamp?: string;
-    name?: string;
-    tool_call_id?: string;
-    args?: any;
-    branch_id?: string;
-    sequence_number?: number;
-    isMarkdown?: boolean;
-    agentName?: string;
-}
-export interface ChatSettings {
-    appearance: {
-        theme: 'light' | 'dark' | 'system';
-    };
-    jsonFormatting: {
-        enabled: boolean;
-        theme: 'professional' | 'clean' | 'minimal' | 'dark';
-        compactMode: boolean;
-        showIcons: boolean;
-        highlightMissingData: boolean;
-        missingDataStyle: 'red' | 'yellow' | 'gray';
-        maxHeight: number;
-        autoDetectStructure: boolean;
-    };
-    messageDisplay: {
-        showTimestamps: boolean;
-        showAgentNames: boolean;
-        compactMessages: boolean;
-        showToolCalls: boolean;
-    };
-    chatBehavior: {
-        autoScroll: boolean;
-        soundEnabled: boolean;
-        typewriterEffect: boolean;
-    };
-}
-export interface Thread {
-    id: string;
-    title?: string;
-    updated_at: string;
-    created_at: string;
-}
-export interface Branch {
-    branch_id: string;
-    created_at: string;
-    from_message_index: number;
-    last_sequence: number;
-    message_count: number;
-    preview: string;
-    is_current?: boolean;
-}
-interface ChatState {
+/**
+ * Chat Provider - Clean, exportable chat context
+ * Designed for use across multiple applications with consistent API
+ */
+import { ReactNode } from 'react';
+import { Message, ThreadResponse, ChatSettings, CreateThreadRequest, ApiConfig } from '@/types/api';
+interface ChatContextValue {
     currentThreadId: string | null;
+    threads: ThreadResponse[];
     messages: Message[];
     isLoading: boolean;
     isLoadingHistory: boolean;
     error: string | null;
-    interrupt: any;
-    threads: Thread[];
-    loadingThreads: boolean;
-    availableBranches: Branch[];
-    currentBranch: string | null;
     settings: ChatSettings;
-}
-interface ChatActions {
-    selectThread: (threadId: string | null) => void;
-    createThread: () => Promise<string>;
+    createThread: (request?: CreateThreadRequest) => Promise<string>;
+    loadThread: (threadId: string) => Promise<void>;
     deleteThread: (threadId: string) => Promise<void>;
     updateThreadTitle: (threadId: string, title: string) => Promise<void>;
-    sendMessage: (content: string, files?: File[]) => Promise<void>;
-    editMessage: (message: Message, newContent: string, rerun?: boolean, editFromInput?: boolean) => Promise<void>;
-    regenerateFromMessage: (message: Message, newContent?: string) => Promise<void>;
-    stop: () => void;
-    switchBranch: (branchId: string) => Promise<void>;
-    updateSettings: (settings: Partial<ChatSettings>) => void;
-    resetSettings: () => void;
+    sendMessage: (content: string, options?: {
+        branchId?: number;
+        saveToStorage?: boolean;
+        originalMessageId?: string;
+    }) => Promise<void>;
+    editMessage: (messageId: string, newContent: string) => Promise<void>;
+    regenerateFromMessage: (messageIndex: number) => Promise<void>;
+    stopStream: () => void;
     clearError: () => void;
-    refresh: () => Promise<void>;
+    refreshThreads: () => Promise<void>;
+    updateSettings: (newSettings: Partial<ChatSettings>) => void;
+    currentBranchId: string | null;
+    availableBranches: any[];
+    branchPointMessageIds: string[];
+    switchBranch: (branchId: string) => Promise<void>;
+    messageVariants: Record<string, Record<string, Message>>;
+    switchableMessageIds: string[];
+    edgeSwitchMap: Record<string, string[]>;
 }
-interface ChatProviderProps {
-    children: React.ReactNode;
-    apiBaseUrl?: string;
-    enableUrlSync?: boolean;
-    getAuthHeaders?: () => Record<string, string>;
-    authToken?: string;
+export interface ChatProviderProps {
+    children: ReactNode;
+    apiConfig?: ApiConfig;
+    initialSettings?: Partial<ChatSettings>;
+    onError?: (error: string) => void;
+    onThreadChange?: (threadId: string | null) => void;
+    onMessageUpdate?: (messages: Message[]) => void;
+    initialThreadId?: string;
 }
-export declare function ChatProvider({ children, apiBaseUrl, enableUrlSync, getAuthHeaders, authToken }: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useChat(): ChatState & ChatActions;
+export declare function ChatProvider({ children, apiConfig, initialSettings, onError, onThreadChange, onMessageUpdate, initialThreadId }: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useChat(): ChatContextValue;
 export {};

package/dist/components/chat/InlineBranchSelector.d.ts

@@ -0,0 +1,13 @@
+interface Branch {
+    branchId: string;
+    messageCount: number;
+    lastTimestamp: string;
+}
+interface InlineBranchSelectorProps {
+    branches: Branch[];
+    currentBranchId: string;
+    onBranchChange: (branchId: string) => void;
+    compact?: boolean;
+}
+export declare function InlineBranchSelector({ branches, currentBranchId, onBranchChange, compact }: InlineBranchSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/MessageComponent.d.ts

@@ -1,14 +1,36 @@
-import { Message } from './ChatProvider';
-interface MessageComponentProps {
+/**
+ * Message Component - With truncatable tool messages and responsive design
+ */
+import { Message } from '@/types/api';
+export interface MessageComponentProps {
     message: Message;
-    onRegenerate?: (message: Message) => void;
-    onEditMessage?: (message: Message, newContent: string, rerun?: boolean, editInInput?: boolean) => void;
-    showRegenerate?: boolean;
-    showBranches?: boolean;
-    branches?: any[];
-    onSwitchBranch?: (branchId: string) => void;
-    messageIndex?: number;
-    currentBranch?: string;
+    messageIndex: number;
+    isEditing?: boolean;
+    showActions?: boolean;
+    showTimestamp?: boolean;
+    showAgentName?: boolean;
+    layoutSize?: 'phone' | 'tablet' | 'desktop' | 'half-screen';
+    truncateToolMessages?: boolean;
+    toolMessagePreviewLength?: number;
+    customStyles?: {
+        container?: string;
+        content?: string;
+        actions?: string;
+        header?: string;
+    };
+    availableBranches?: Array<{
+        branchId: string;
+        messageCount: number;
+        lastTimestamp: string;
+    }>;
+    currentBranchId?: string | null;
+    onBranchSwitch?: (branchId: string) => void;
+    switchableMessageIds?: string[];
+    edgeSwitchMap?: Record<string, string[]>;
+    onEdit?: (messageId: string, content: string) => void;
+    onRegenerate?: (messageIndex: number) => void;
+    onCancelEdit?: () => void;
+    onCopy?: (content: string) => void;
 }
-export declare function MessageComponent({ message, onRegenerate, onEditMessage, showRegenerate, showBranches, branches, onSwitchBranch, messageIndex, currentBranch }: MessageComponentProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function MessageComponent({ message, messageIndex, isEditing, showActions, showTimestamp, showAgentName, layoutSize, truncateToolMessages, toolMessagePreviewLength, customStyles, availableBranches, currentBranchId, onBranchSwitch, switchableMessageIds, edgeSwitchMap, // NEW
+onEdit, onRegenerate, onCancelEdit, onCopy }: MessageComponentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ResponsiveChatContainer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Responsive Chat Container - Handles different screen sizes and layouts
+ */
+import React from 'react';
+interface ResponsiveChatContainerProps {
+    children: React.ReactNode;
+    layoutSize: 'phone' | 'tablet' | 'desktop' | 'half-screen';
+    className?: string;
+}
+export declare function ResponsiveChatContainer({ children, layoutSize, className }: ResponsiveChatContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/ThreadManager.d.ts

@@ -1,7 +1,22 @@
-interface ThreadManagerProps {
+/**
+ * Thread Manager - Clean, exportable thread management UI
+ * Handles thread listing, creation, and navigation
+ */
+export interface ThreadManagerProps {
     className?: string;
     showCreateButton?: boolean;
-    onThreadSelect?: (threadId: string | null) => void;
+    showDeleteButton?: boolean;
+    showEditTitle?: boolean;
+    maxHeight?: string;
+    customStyles?: {
+        container?: string;
+        threadList?: string;
+        threadItem?: string;
+        activeThread?: string;
+        createButton?: string;
+    };
+    onThreadSelect?: (threadId: string) => void;
+    onThreadCreate?: (threadId: string) => void;
+    onThreadDelete?: (threadId: string) => void;
 }
-export declare function ThreadManager({ className, showCreateButton, onThreadSelect }: ThreadManagerProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function ThreadManager({ className, showCreateButton, showDeleteButton, showEditTitle, maxHeight, customStyles, onThreadSelect, onThreadCreate, onThreadDelete }: ThreadManagerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/chat-routing.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface ChatRoutingConfig {
+    basePath?: string;
+}
+interface ChatRoutingValue {
+    basePath: string;
+    buildThreadPath: (threadId: string) => string;
+    buildBasePath: () => string;
+}
+export declare function ChatRoutingProvider({ children, basePath }: {
+    children: ReactNode;
+    basePath?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useChatRouting(): ChatRoutingValue;
+export {};

package/dist/components/chat/index.d.ts

@@ -1,17 +1,15 @@
-export { ChatApp } from './ChatApp';
+/**
+ * Chat Components - Export index
+ * Clean exports for use in other applications
+ */
+export { ChatApp, SimpleChat } from './ChatApp';
 export { ChatProvider, useChat } from './ChatProvider';
-export { ThreadManager } from './ThreadManager';
 export { ChatInterface } from './ChatInterface';
+export { ThreadManager } from './ThreadManager';
 export { MessageComponent } from './MessageComponent';
-export { ChatWidget } from './ChatWidget';
-export { ChatHeader } from './ChatHeader';
-export { ChatSettingsButton } from './ChatSettingsButton';
-export { ChatSettingsModal } from './ChatSettingsModal';
-export { JsonRenderer } from './JsonRenderer';
-export { JsonRendererProvider, useJsonRenderer } from './JsonRendererConfig';
-export { useChatJsonSync } from './useChatJsonSync';
-export { useChatMessages, useToolMessages, useChatActions } from '../../hooks/useChatMessages';
-export { useStreamMonitor, useToolExtractor, useSearchResults, useFileContents, useCodeExecution } from '../../hooks/useStreamMonitor';
-export type { Message, Thread, Branch } from './ChatProvider';
-export type { ToolMessage, ProcessedToolMessage } from '../../hooks/useChatMessages';
-export type { StreamEvent, StreamState } from '../../hooks/useStreamMonitor';
+export { InlineBranchSelector } from './InlineBranchSelector';
+export { useApiClient } from '@/hooks/useApiClient';
+export type { Message, Thread, ApiConfig, StreamEvent, CreateThreadRequest, StreamRequest, ThreadResponse } from '@/types/api';
+export { ChatSettings } from '@/components/settings/ChatSettings';
+export type { ChatSettingsConfig } from '@/components/settings/ChatSettings';
+export { ChatApp as default } from './ChatApp';

package/dist/components/settings/ChatSettings.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Chat Settings Component - Persistent settings with beautiful UI
+ * Handles API configuration, layout preferences, and chat behavior
+ */
+export interface ChatSettingsConfig {
+    api: {
+        baseUrl: string;
+        authToken: string;
+        enableAuth: boolean;
+    };
+    ui: {
+        layout: 'sidebar' | 'fullscreen' | 'tabs';
+        theme: 'light' | 'dark' | 'system';
+        showTimestamps: boolean;
+        showAgentNames: boolean;
+        compactMessages: boolean;
+    };
+    behavior: {
+        autoSave: boolean;
+        enableStreaming: boolean;
+        showTypingIndicator: boolean;
+    };
+}
+interface ChatSettingsProps {
+    settings: ChatSettingsConfig;
+    onSettingsChange: (settings: ChatSettingsConfig) => void;
+    className?: string;
+}
+export declare function ChatSettings({ settings, onSettingsChange, className }: ChatSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/resizable.d.ts

@@ -1,6 +1,6 @@
 import * as ResizablePrimitive from "react-resizable-panels";
 declare const ResizablePanelGroup: ({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => import("react/jsx-runtime").JSX.Element;
-declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLButtonElement | HTMLElement | HTMLTextAreaElement | HTMLDivElement | HTMLParagraphElement | HTMLHeadingElement | HTMLSpanElement | HTMLBRElement | HTMLPreElement | HTMLObjectElement | HTMLUListElement | HTMLOListElement | HTMLLIElement | HTMLQuoteElement | HTMLAnchorElement | HTMLTitleElement | HTMLInputElement | HTMLProgressElement | HTMLSelectElement | HTMLMapElement | HTMLLinkElement | HTMLFormElement | HTMLSlotElement | HTMLStyleElement | HTMLDialogElement | HTMLImageElement | HTMLOptionElement | HTMLTableElement | HTMLDataElement | HTMLLabelElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLBodyElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLHeadElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLLegendElement | HTMLMetaElement | HTMLMeterElement | HTMLOptGroupElement | HTMLOutputElement | HTMLScriptElement | HTMLSourceElement | HTMLTemplateElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTimeElement | HTMLTableRowElement | HTMLTrackElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLButtonElement | HTMLElement | HTMLInputElement | HTMLDivElement | HTMLObjectElement | HTMLMapElement | HTMLLinkElement | HTMLFormElement | HTMLSlotElement | HTMLStyleElement | HTMLTitleElement | HTMLDialogElement | HTMLImageElement | HTMLOptionElement | HTMLTableElement | HTMLAnchorElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBodyElement | HTMLBRElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLHeadingElement | HTMLHeadElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLLabelElement | HTMLLegendElement | HTMLLIElement | HTMLMetaElement | HTMLMeterElement | HTMLOListElement | HTMLOptGroupElement | HTMLOutputElement | HTMLParagraphElement | HTMLPreElement | HTMLProgressElement | HTMLScriptElement | HTMLSelectElement | HTMLSourceElement | HTMLSpanElement | HTMLTemplateElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTableRowElement | HTMLTrackElement | HTMLUListElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
     className?: string | undefined;
     collapsedSize?: number | undefined;
     collapsible?: boolean | undefined;

package/dist/hooks/useApiClient.d.ts

@@ -0,0 +1,34 @@
+/**
+ * API client hook for aiNav backend
+ * Handles all HTTP requests with proper error handling and type safety
+ */
+import { Thread, CreateThreadRequest, CreateThreadResponse, ThreadListResponse, ThreadMessagesResponse, UpdateThreadRequest, EditMessageRequest, EditMessageResponse, StreamRequest, StreamChatRequest, DeleteResponse, StreamEvent } from '@/types/api';
+export interface UseApiClientProps {
+    baseUrl?: string;
+    authToken?: string;
+    getAuthHeaders?: () => Record<string, string>;
+}
+export declare function useApiClient({ baseUrl, authToken, getAuthHeaders }?: UseApiClientProps): {
+    isLoading: boolean;
+    error: string;
+    isOffline: boolean;
+    retryCount: number;
+    clearError: () => void;
+    createThread: (request: CreateThreadRequest) => Promise<CreateThreadResponse>;
+    getThreads: () => Promise<ThreadListResponse>;
+    getThread: (threadId: string) => Promise<Thread>;
+    updateThread: (threadId: string, request: UpdateThreadRequest) => Promise<Thread>;
+    deleteThread: (threadId: string) => Promise<DeleteResponse>;
+    getThreadMessages: (threadId: string) => Promise<ThreadMessagesResponse>;
+    editMessage: (threadId: string, request: EditMessageRequest) => Promise<EditMessageResponse>;
+    getThreadState: (threadId: string) => Promise<{
+        thread_id: string;
+        state: any;
+    }>;
+    setThreadState: (threadId: string, state: any) => Promise<{
+        thread_id: string;
+        state: any;
+    }>;
+    streamChat: (request: StreamRequest, onMessage: (event: StreamEvent) => void, onError?: (error: Error) => void, onComplete?: () => void) => Promise<void>;
+    streamChatSimple: (request: StreamChatRequest, onMessage: (event: StreamEvent) => void, onError?: (error: Error) => void, onComplete?: () => void) => Promise<void>;
+};