teodor-new-chat-ui 4.0.6 → 4.0.7

package/dist/context/ApiProvider.d.ts

@@ -0,0 +1,2 @@
+export { ApiProvider, useApi } from './providers/ApiProvider';
+export type { ApiProviderProps } from './providers/ApiProvider';

package/dist/context/ChatProvider.d.ts

@@ -1,68 +1,2 @@
-import React from "react";
-import { ChatMessage, ThreadSummary, CheckpointList, ApiConfig } from "@/types/api";
-import { ChatApi } from "@/lib/chat-api";
-export interface SendOptions {
-    checkpointId?: string;
-    checkpointNs?: string;
-    nodeFilter?: string;
-    config?: Record<string, unknown>;
-    payloadExtras?: Record<string, unknown>;
-    attachments?: File[];
-}
-export interface ChatContextValue {
-    baseUrl: string;
-    token: string | null;
-    setToken: (t: string | null) => void;
-    api: ChatApi;
-    threads: ThreadSummary[];
-    currentThreadId: string | null;
-    setCurrentThreadId: (id: string | null) => void;
-    isLoadingThreads: boolean;
-    isLoadingThread: boolean;
-    messages: ChatMessage[];
-    isStreaming: boolean;
-    error: string | null;
-    lastCheckpointId: string | null;
-    lastCheckpointNs: string | null;
-    streamingAssistantId: string | null;
-    hasMoreHistory: boolean;
-    isLoadingHistory: boolean;
-    loadOlderMessages: (opts?: {
-        limit?: number;
-    }) => Promise<void>;
-    historyPageSize: number;
-    listCheckpoints: (threadId: string) => Promise<CheckpointList>;
-    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
-    returnToLatest: () => Promise<void>;
-    refreshThreads: () => Promise<void>;
-    createThread: (title?: string) => Promise<string>;
-    deleteThread: (threadId: string) => Promise<void>;
-    renameThread: (threadId: string, title: string) => Promise<void>;
-    loadThread: (threadId: string, checkpointId?: string, checkpointNs?: string, force?: boolean) => Promise<void>;
-    clearCurrentThread: () => Promise<void>;
-    send: (text: string, opts?: SendOptions) => Promise<void>;
-    stop: () => void;
-    handleInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
-}
-export declare const ChatContext: React.Context<ChatContextValue>;
-export interface ChatProviderProps {
-    children: React.ReactNode;
-    apiConfig?: ApiConfig;
-    onError?: (error: string) => void;
-    onThreadChange?: (threadId: string | null) => void;
-    initialThreadId?: string | null;
-    /**
-     * If true the provider will attempt to auto-load `initialThreadId` when mounted.
-     * Set to false to defer initial loading to the host application.
-     */
-    autoLoadInitial?: boolean;
-    /**
-     * If true, prevents auto-loading from localStorage on mount.
-     * Useful when you want full control over initial thread without localStorage interference.
-     */
-    disableAutoRestore?: boolean;
-    enableFileAgentRouting?: boolean;
-    fileAgentId?: string;
-}
-export declare function ChatProvider({ children, apiConfig, onError, onThreadChange, initialThreadId, autoLoadInitial, disableAutoRestore, enableFileAgentRouting, fileAgentId }: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useChat(): ChatContextValue;
+export { ChatProvider, ChatContext, useChat, } from './providers/ChatProvider';
+export type { ChatProviderProps, ChatContextValue, SendOptions, } from './providers/ChatProvider';

package/dist/context/ChatProviders.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ChatProviders - Root provider that composes all chat contexts
+ *
+ * Context hierarchy:
+ * ApiProvider (auth token & API client)
+ * └─ StreamProvider (streaming status)
+ *    └─ ThreadProvider (thread list & current thread)
+ *       └─ MessagesProvider (messages for current thread)
+ */
+import { type ReactNode } from 'react';
+import type { ApiConfig } from '@/types/api';
+export interface ChatProvidersProps {
+    children: ReactNode;
+    apiConfig?: ApiConfig;
+    initialThreadId?: string | null;
+    autoLoadInitial?: boolean;
+    disableAutoRestore?: boolean;
+    enableFileAgentRouting?: boolean;
+    fileAgentId?: string;
+    onError?: (error: string) => void;
+    onThreadChange?: (threadId: string | null) => void;
+}
+export declare function ChatProviders({ children, apiConfig, initialThreadId, autoLoadInitial, disableAutoRestore, enableFileAgentRouting, fileAgentId, onError, onThreadChange, }: ChatProvidersProps): import("react/jsx-runtime").JSX.Element;
+export { useApi } from './ApiProvider';
+export { useStream } from './StreamProvider';
+export { useThreads } from './ThreadProvider';
+export { useMessages } from './MessagesProvider';
+export type { ApiContextValue, StreamContextValue, ThreadContextValue, MessagesContextValue, SendOptions, } from './types';

package/dist/context/MessagesProvider.d.ts

@@ -0,0 +1,2 @@
+export { MessagesProvider, useMessages } from './providers/MessagesProvider';
+export type { MessagesProviderProps } from './providers/MessagesProvider';

package/dist/context/StreamProvider.d.ts

@@ -0,0 +1,2 @@
+export { StreamProvider, useStream, useStreamDispatch, } from './providers/StreamProvider';
+export type { StreamAction } from './providers/StreamProvider';

package/dist/context/ThreadProvider.d.ts

@@ -0,0 +1,2 @@
+export { ThreadProvider, useThreads, useThreadDispatch, ThreadProviderWithCallbacks, } from './providers/ThreadProvider';
+export type { ThreadProviderProps } from './providers/ThreadProvider';

package/dist/context/{useStreamEventCoordinator.d.ts → hooks/useStreamEventCoordinator.d.ts}

@@ -1,17 +1,8 @@
 import type { StreamEvent } from "@/types/api";
-import { type ReducerStreamEvent } from "./MessageReducer";
-import type { MutableRefObject } from "react";
+import { type ReducerStreamEvent } from "../reducers/MessageReducer";
 export type ThreadInfoEvent = Extract<StreamEvent, {
     type: "thread_info";
 }>;
-interface ThreadInfoHandlerOptions {
-    currentThreadId: string | null;
-    messageCount: number;
-    setCurrentThreadId: (id: string | null) => void;
-    markThreadRefreshPending: () => void;
-    skipNextLoadRef: MutableRefObject<string | null>;
-}
-export declare function useThreadInfoHandler({ currentThreadId, messageCount, setCurrentThreadId, markThreadRefreshPending, skipNextLoadRef, }: ThreadInfoHandlerOptions): (ev: ThreadInfoEvent) => void;
 interface CoordinatorOptions {
     onThreadInfo?: (ev: ThreadInfoEvent) => void;
     onMessageEvent: (ev: ReducerStreamEvent) => void;

package/dist/context/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Context Module - Public API
+ *
+ * Organized structure:
+ * - providers/   - All React Context providers
+ * - reducers/    - State management logic
+ * - hooks/       - Shared hooks for event coordination
+ * - legacy/      - Deprecated code (to be removed)
+ */
+export { ChatProviders } from './ChatProviders';
+export { ApiProvider, useApi } from './providers/ApiProvider';
+export { StreamProvider, useStream, useStreamDispatch } from './providers/StreamProvider';
+export { ThreadProvider, useThreads, ThreadProviderWithCallbacks } from './providers/ThreadProvider';
+export { MessagesProvider, useMessages } from './providers/MessagesProvider';
+export { ChatProvider, useChat } from './providers/ChatProvider';
+export type { ChatContextValue } from './providers/ChatProvider';
+export { useMessagesReducer } from './reducers/MessageReducer';
+export type { ReducerStreamEvent } from './reducers/MessageReducer';
+export { useStreamEventCoordinator } from './hooks/useStreamEventCoordinator';
+export type { ThreadInfoEvent } from './hooks/useStreamEventCoordinator';
+export type { SendOptions, ApiContextValue, StreamContextValue, MessagesContextValue, ThreadContextValue, CoordinatorOptions, } from '@/types/api';

package/dist/context/providers/ApiProvider.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ApiProvider - Lowest level context providing API client and auth token
+ */
+import { type ReactNode } from 'react';
+import type { ApiContextValue, ApiConfig } from '@/types/api';
+export interface ApiProviderProps {
+    children: ReactNode;
+    apiConfig?: ApiConfig;
+}
+export declare function ApiProvider({ children, apiConfig }: ApiProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useApi(): ApiContextValue;

package/dist/context/providers/ChatProvider.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ChatProvider - Compatibility layer that provides the original ChatProvider API
+ * using the new split context architecture underneath
+ *
+ * This allows existing code to continue working without changes while
+ * benefiting from the performance improvements of split contexts.
+ */
+import React, { type ReactNode } from 'react';
+import { useApi } from './ApiProvider';
+import type { ApiConfig, ChatMessage, CheckpointList, ThreadSummary, SendOptions } from '@/types/api';
+export interface ChatContextValue {
+    baseUrl: string;
+    token: string | null;
+    setToken: (t: string | null) => void;
+    api: ReturnType<typeof useApi>['api'];
+    threads: ThreadSummary[];
+    currentThreadId: string | null;
+    setCurrentThreadId: (id: string | null) => void;
+    isLoadingThreads: boolean;
+    isLoadingThread: boolean;
+    messages: ChatMessage[];
+    isStreaming: boolean;
+    error: string | null;
+    lastCheckpointId: string | null;
+    lastCheckpointNs: string | null;
+    streamingAssistantId: string | null;
+    hasMoreHistory: boolean;
+    isLoadingHistory: boolean;
+    loadOlderMessages: (opts?: {
+        limit?: number;
+    }) => Promise<void>;
+    historyPageSize: number;
+    listCheckpoints: (threadId: string) => Promise<CheckpointList>;
+    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
+    returnToLatest: () => Promise<void>;
+    refreshThreads: () => Promise<void>;
+    createThread: (title?: string) => Promise<string>;
+    deleteThread: (threadId: string) => Promise<void>;
+    renameThread: (threadId: string, title: string) => Promise<void>;
+    loadThread: (threadId: string, checkpointId?: string, checkpointNs?: string, force?: boolean) => Promise<void>;
+    clearCurrentThread: () => Promise<void>;
+    send: (text: string, opts?: SendOptions) => Promise<void>;
+    stop: () => void;
+    handleInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
+}
+export declare const ChatContext: React.Context<ChatContextValue>;
+export interface ChatProviderProps {
+    children: ReactNode;
+    apiConfig?: ApiConfig;
+    onError?: (error: string) => void;
+    onThreadChange?: (threadId: string | null) => void;
+    initialThreadId?: string | null;
+    autoLoadInitial?: boolean;
+    disableAutoRestore?: boolean;
+    enableFileAgentRouting?: boolean;
+    fileAgentId?: string;
+}
+export declare function ChatProvider(props: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useChat(): ChatContextValue;
+export type { SendOptions } from '@/types/api';

package/dist/context/providers/MessagesProvider.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MessagesProvider - Manages messages, streaming, and message operations
+ * Coordinates with ThreadProvider and StreamProvider
+ */
+import { type ReactNode } from 'react';
+import type { MessagesContextValue } from '@/types/api';
+export interface MessagesProviderProps {
+    children: ReactNode;
+    enableFileAgentRouting?: boolean;
+    fileAgentId?: string;
+}
+export declare function MessagesProvider(props: MessagesProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useMessages(): MessagesContextValue;

package/dist/context/providers/StreamProvider.d.ts

@@ -0,0 +1,29 @@
+/**
+ * StreamProvider - Manages streaming state (isStreaming, error, checkpoints)
+ * This context is updated by events from the coordinator but doesn't own the stream itself
+ */
+import React, { type ReactNode } from 'react';
+import type { StreamContextValue } from '@/types/api';
+export type StreamAction = {
+    type: 'STREAM_START';
+    assistantId?: string;
+} | {
+    type: 'STREAM_END';
+} | {
+    type: 'STREAM_ERROR';
+    error: string;
+} | {
+    type: 'UPDATE_CHECKPOINT';
+    checkpointId: string;
+    checkpointNs?: string | null;
+} | {
+    type: 'UPDATE_ASSEMBLING_ID';
+    assistantId: string | null;
+} | {
+    type: 'CLEAR_ERROR';
+};
+export declare function StreamProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useStream(): StreamContextValue;
+export declare function useStreamDispatch(): React.Dispatch<StreamAction>;

package/dist/context/providers/ThreadProvider.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ThreadProvider - Manages thread list, current thread, and thread operations
+ */
+import { type ReactNode } from 'react';
+import type { ThreadContextValue, MessagesPayload } from '@/types/api';
+export interface ThreadProviderProps {
+    children: ReactNode;
+    initialThreadId?: string | null;
+    autoLoadInitial?: boolean;
+    disableAutoRestore?: boolean;
+    onThreadChange?: (threadId: string | null) => void;
+    onError?: (error: string) => void;
+}
+export declare function ThreadProvider({ children, initialThreadId, autoLoadInitial, disableAutoRestore, onThreadChange, onError, }: ThreadProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useThreads(): ThreadContextValue;
+export declare function useThreadDispatch(): {
+    onThreadLoaded: (threadId: string, payload: MessagesPayload) => void;
+    onThreadCleared: () => void;
+};
+export declare function ThreadProviderWithCallbacks({ children, onThreadLoaded, onThreadCleared, ...props }: ThreadProviderProps & {
+    onThreadLoaded: (threadId: string, payload: MessagesPayload) => void;
+    onThreadCleared: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/context/types.d.ts

@@ -0,0 +1 @@
+export type { ApiContextValue, StreamContextValue, MessagesContextValue, ThreadContextValue, SendOptions, StreamEvent, MessageAction, StreamAction, ThreadAction, CoordinatorOptions, } from '@/types/api';