teodor-new-chat-ui 4.0.27 → 4.0.28

package/dist/context/ChatProviders.d.ts

@@ -3,9 +3,7 @@
  *
  * Context hierarchy:
  * ApiProvider (auth token & API client)
- * └─ StreamProvider (streaming status)
- *    └─ ThreadProvider (thread list & current thread)
- *       └─ MessagesProvider (messages for current thread)
+ * └─ ChatSessionProvider (threads, messages, and streaming state)
  */
 import { type ReactNode } from 'react';
 import type { ApiConfig } from '@/types/api';
@@ -22,7 +20,5 @@ export interface ChatProvidersProps {
 }
 export declare function ChatProviders({ children, apiConfig, initialThreadId, autoLoadInitial, disableAutoRestore, enableFileAgentRouting, fileAgentId, onError, onThreadChange, }: ChatProvidersProps): import("react/jsx-runtime").JSX.Element;
 export { useApi } from './providers/ApiProvider';
-export { useStream } from './providers/StreamProvider';
-export { useThreads } from './providers/ThreadProvider';
-export { useMessages } from './providers/MessagesProvider';
+export { useStream, useThreads, useMessages } from './providers/ChatSessionProvider';
 export type { ApiContextValue, StreamContextValue, ThreadContextValue, MessagesContextValue, SendOptions, } from './types';

package/dist/context/index.d.ts

@@ -4,16 +4,15 @@
  * Organized structure:
  * - providers/   - All React Context providers
  * - reducers/    - State management logic
- * - hooks/       - Shared hooks for event coordination
+ * - services/    - Non-React utilities used by providers
  * - legacy/      - Deprecated code (to be removed)
  */
 export { ChatProviders } from './ChatProviders';
 export { ApiProvider, useApi } from './providers/ApiProvider';
-export { StreamProvider, useStream, useStreamDispatch } from './providers/StreamProvider';
+export { StreamProvider, useStream } from './providers/StreamProvider';
 export { ThreadProvider, useThreads, ThreadProviderWithCallbacks } from './providers/ThreadProvider';
 export { MessagesProvider, useMessages } from './providers/MessagesProvider';
+export { ChatSessionProvider, useHasChatSession } from './providers/ChatSessionProvider';
 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/ChatSessionProvider.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { MessagesContextValue, StreamContextValue, ThreadContextValue } from '@/types/api';
+interface ChatSessionProviderPropsBase {
+    children: ReactNode;
+    initialThreadId?: string | null;
+    autoLoadInitial?: boolean;
+    disableAutoRestore?: boolean;
+    enableFileAgentRouting?: boolean;
+    fileAgentId?: string;
+    onError?: (error: string) => void;
+    onThreadChange?: (threadId: string | null) => void;
+}
+export type ChatSessionProviderProps = ChatSessionProviderPropsBase;
+export declare function ChatSessionProvider({ children, initialThreadId, autoLoadInitial, disableAutoRestore, enableFileAgentRouting, fileAgentId, onError, onThreadChange, }: ChatSessionProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useThreads(): ThreadContextValue;
+export declare function useMessages(): MessagesContextValue;
+export declare function useStream(): StreamContextValue;
+export declare function useHasChatSession(): boolean;
+export {};

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

@@ -1,17 +1,10 @@
+import { useMessages, type ChatSessionProviderProps } from './ChatSessionProvider';
 /**
- * MessagesProvider - Manages messages, streaming, and message operations
- * Coordinates with ThreadProvider and StreamProvider
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
  */
-import { type ReactNode } from 'react';
-import type { MessagesContextValue, MessagesPayload } from '@/types/api';
-export interface MessagesProviderProps {
-    children: ReactNode;
-    enableFileAgentRouting?: boolean;
-    fileAgentId?: string;
-    onRegisterThreadCallbacks?: (callbacks: {
-        onThreadLoaded: (threadId: string, payload: MessagesPayload) => void;
-        onThreadCleared: () => void;
-    }) => void;
-}
-export declare function MessagesProvider(props: MessagesProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useMessages(): MessagesContextValue;
+export type MessagesProviderProps = ChatSessionProviderProps;
+/**
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
+ */
+export declare function MessagesProvider({ children, ...rest }: MessagesProviderProps): import("react/jsx-runtime").JSX.Element;
+export { useMessages };

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

@@ -1,29 +1,10 @@
+import { useStream, type ChatSessionProviderProps } from './ChatSessionProvider';
 /**
- * StreamProvider - Manages streaming state (isStreaming, error, checkpoints)
- * This context is updated by events from the coordinator but doesn't own the stream itself
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
  */
-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>;
+export type StreamProviderProps = ChatSessionProviderProps;
+/**
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
+ */
+export declare function StreamProvider({ children, ...rest }: StreamProviderProps): import("react/jsx-runtime").JSX.Element;
+export { useStream };

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

@@ -1,23 +1,14 @@
+import { useThreads, type ChatSessionProviderProps } from './ChatSessionProvider';
 /**
- * ThreadProvider - Manages thread list, current thread, and thread operations
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
  */
-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;
+export type ThreadProviderProps = ChatSessionProviderProps;
+/**
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
+ */
+export declare function ThreadProvider({ children, ...rest }: ThreadProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * @deprecated Use ChatSessionProvider directly. This wrapper exists for backward compatibility.
+ */
+export declare const ThreadProviderWithCallbacks: typeof ThreadProvider;
+export { useThreads };

package/dist/context/services/useChatStreamingService.d.ts

@@ -0,0 +1,40 @@
+import { type ReducerStreamEvent } from '../reducers/MessageReducer';
+import type { ChatRequest, StreamEvent } from '@/types/api';
+export type ThreadInfoEvent = Extract<StreamEvent, {
+    type: 'thread_info';
+}>;
+interface UseChatStreamingServiceOptions {
+    baseUrl: string;
+    onThreadInfo: (event: ThreadInfoEvent) => void;
+    onMessageEvent: (event: ReducerStreamEvent) => void;
+    onUnhandledEvent?: (event: StreamEvent) => void;
+    onSequenceGap?: (gap: {
+        from: number;
+        to: number;
+    }) => void;
+}
+interface StartStreamCallbacks {
+    onOpen?: (info: {
+        threadId: string | null;
+        created: boolean;
+    }) => void;
+    onError?: (error: unknown) => void;
+    onGap?: (gap: {
+        from: number;
+        to: number;
+    }) => void;
+}
+/**
+ * Thin integration layer that adapts the public `useChatStream` hook to the
+ * coordination callbacks expected by `ChatSessionProvider`. Keeping this logic
+ * here means we continue to rely on the well-tested streaming hook for all SSE
+ * behaviour while the provider focuses purely on state updates.
+ */
+export declare function useChatStreamingService({ baseUrl, onThreadInfo, onMessageEvent, onUnhandledEvent, onSequenceGap, }: UseChatStreamingServiceOptions): {
+    startStream: (request: ChatRequest, callbacks?: StartStreamCallbacks) => void;
+    stop: () => void;
+    isStreaming: boolean;
+    error: string;
+    setAuthToken: (t: string | null) => void;
+};
+export {};