@teodorruskvi/chat-core 0.1.34 → 0.1.36

package/dist/features/conversation/contexts/ThreadsProvider.d.ts

@@ -7,4 +7,9 @@ export interface ThreadsProviderProps {
     onThreadChange?: (threadId: string | null) => void;
 }
 export declare function ThreadsProvider({ children, initialThreadId, onError, onThreadChange, }: ThreadsProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useThreads(): ThreadsContextValue;
+export declare function useThreads(options: {
+    optional: true;
+}): ThreadsContextValue | null;
+export declare function useThreads(options?: {
+    optional?: false;
+}): ThreadsContextValue;

package/dist/features/conversation/contexts/reducers/MessageReducer.d.ts

@@ -1,20 +1,17 @@
 import type { ChatMessage } from "@/types";
 import type { StreamEvent } from "@/types/domain/streaming";
-import type { MessagesState, MessagesAction } from "@/types/domain/messages";
+import type { MessagesState, MessagesAction, ChatStatus } from "@/types/domain/messages";
 export declare const initialMessagesState: MessagesState;
 export declare function messagesReducer(state: MessagesState, action: MessagesAction): MessagesState;
 export declare function useMessagesReducer(initial?: ChatMessage[]): {
+    readonly setStatus: (status: ChatStatus, error?: string | null) => void;
     readonly reset: (messages?: ChatMessage[]) => void;
     readonly seed: (messages: ChatMessage[], opts?: {
         checkpointId?: string | null;
         checkpointNs?: string | null;
-        pendingInterrupt?: {
-            id: string;
-            value: any;
-        } | null;
+        pendingInterrupt?: any | null;
         values?: Record<string, any>;
     }) => void;
-    readonly prepend: (messages: ChatMessage[]) => void;
     readonly pushUser: (message: ChatMessage, editingMessageId?: string | null) => void;
     readonly onEvent: (ev: StreamEvent) => void;
     readonly state: MessagesState;

package/dist/features/conversation/hooks/useChatSession.d.ts

@@ -1,22 +1,22 @@
 type UseChatSessionOptions = string | {
     threadId?: string;
+    lazy?: boolean;
 } | undefined;
-export declare function useChatSession(options?: UseChatSessionOptions): {
+export declare function useChatSession<TValues = Record<string, any>>(options?: UseChatSessionOptions): {
     threadId: string | null;
+    status: import("../../../types/domain/messages").ChatStatus;
     messages: any[];
     isLoading: boolean;
     isHistoryLoading: boolean;
     error: string | null;
-    values: Record<string, unknown>;
+    values: TValues;
     taskMessagesByScope: Record<string, import("../../../types").ChatMessage[]>;
-    metadata: {
-        assemblingMessageId: string | null;
-    } | undefined;
+    metadata: {} | undefined;
     navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
     returnToLatest: () => Promise<void>;
     checkpoint: {
         id: string | null;
-        namespace: string | null;
+        namespace: string | null | undefined;
     } | null;
     checkpoints: import("../../../types").HydratedCheckpointSnapshot[];
     checkpointIndex: import("../../persistence/checkpoints/utils/checkpointIndex").CheckpointIndex | {
@@ -36,14 +36,12 @@ export declare function useChatSession(options?: UseChatSessionOptions): {
     submit: (input: import("../../../types").StreamSubmitPayload, callbacks?: import("../../../types").StreamCallbacks) => Promise<void>;
     stop: () => void;
     clearThread: () => Promise<void> | void;
-    setCurrentThreadId: (id: string | null) => void;
-    createThread: (title?: string, project?: ({
-        id: string;
-        name?: string;
-    } | import("../../../types").ProjectInfo | null)) => Promise<string | null>;
-    deleteThread: (threadId: string) => Promise<void>;
-    renameThread: (threadId: string, title: string) => Promise<void>;
-    shareThread: (threadId: string, sharedWithUserId: string) => Promise<void>;
+    setCurrentThreadId: ((id: string | null) => void) | (() => void);
+    loadHistory: () => Promise<void>;
+    createThread: any;
+    deleteThread: any;
+    renameThread: any;
+    shareThread: any;
     threads: import("../../../types").ThreadSummary[];
     isThreadsLoading: boolean;
 };

package/dist/features/conversation/hooks/useThreadHistoryState.d.ts

@@ -43,5 +43,9 @@ interface ThreadHistoryResult {
     resetHistoryState: () => void;
     clearState: () => void;
 }
-export declare function useThreadHistoryState({ api, fileApi, seed, onError, currentThreadId, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, isStreaming, getMessages, }: UseThreadHistoryStateOptions): ThreadHistoryResult;
+/**
+ * Refactored useThreadHistoryState
+ * Focuses on a clean loading lifecycle and removes complex imperative refs.
+ */
+export declare function useThreadHistoryState({ api, fileApi, seed, onError, currentThreadId, autoLoadInitial, isStreaming, getMessages, }: UseThreadHistoryStateOptions): ThreadHistoryResult;
 export {};

package/dist/features/streaming/contexts/StreamingProvider.d.ts

@@ -14,6 +14,11 @@ interface StreamingProviderProps {
     onStreamingChange?: (isStreaming: boolean) => void;
 }
 export declare function StreamingProvider({ children, onError, onAuthError, onConnectionError, onToolEnd, onUpdateEvent, onCustomEvent, onMetadataEvent, onFinish, onStreamingChange, }: StreamingProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useStream(): StreamContextValue;
+export declare function useStream(options: {
+    optional: true;
+}): StreamContextValue | null;
+export declare function useStream(options?: {
+    optional?: false;
+}): StreamContextValue;
 export declare function useHasChatSession(): boolean;
 export {};

package/dist/features/streaming/contexts/types.d.ts

@@ -31,6 +31,7 @@ export interface ThreadsContextValue {
     addThreadFromEvent: (threadInfo: ThreadInfoEvent) => void;
 }
 export interface ThreadStateContextValue {
+    status: import("@/types/domain/messages").ChatStatus;
     threadId: string | null;
     messages: ChatMessage[];
     taskMessagesByScope: Record<string, ChatMessage[]>;