teodor-new-chat-ui 4.3.411 → 4.3.412

package/dist/features/core/contexts/providers/ChatProviders.d.ts

@@ -23,4 +23,5 @@ export interface ChatProvidersProps {
 }
 export declare function ChatProviders({ children, apiConfig, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, onConnectionError, onError, onAuthError, onThreadChange, onToolEnd, }: ChatProvidersProps): import("react/jsx-runtime").JSX.Element;
 export { useApi } from '@/features/core/hooks';
-export { useStream, useThreads, useThreadState, useHasChatSession } from '@/features/streaming/contexts/StreamingProvider';
+export { useStream, useHasChatSession } from '@/features/streaming';
+export { useThreads, useThreadState } from '@/features/thread/contexts';

package/dist/features/core/types/models.d.ts

@@ -200,3 +200,4 @@ export type TokenListener = (token: string | null) => void;
 export interface ExcelUploadResponse {
     [key: string]: unknown;
 }
+export declare function isEnvelope(x: unknown): x is Envelope<unknown>;

package/dist/features/messaging/components/{ChatApp.d.ts → chat/ChatApp.d.ts}

@@ -2,7 +2,7 @@
  * Chat App - Complete chat application with sidebar layout
  * Combines all chat components into a ready-to-use chat interface
  */
-import { type ChatProvidersProps } from "@/features/core/contexts/providers/ChatProviders";
+import { type ChatProvidersProps } from "@/features/core";
 export interface ChatAppProps extends Omit<ChatProvidersProps, 'children'> {
     layout?: 'sidebar' | 'fullscreen' | 'tabs';
     layoutSize?: 'phone' | 'tablet' | 'desktop' | 'half-screen';
@@ -21,6 +21,3 @@ export interface SimpleChatProps {
     onError?: (error: string) => void;
 }
 export declare function SimpleChat({ apiConfig, className, onError }: SimpleChatProps): import("react/jsx-runtime").JSX.Element;
-export * from './ChatInterface';
-export * from './ThreadManager';
-export * from './MessageComponent';

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

@@ -0,0 +1,5 @@
+export * from "./ChatApp";
+export { ChatInterface } from "./ChatInterface";
+export type { ChatInterfaceProps } from "./ChatInterface";
+export { ChatInput } from "./ChatInput";
+export type { ChatInputProps } from "./ChatInput";

package/dist/features/messaging/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./chat";
+export * from "./message";
+export * from "./thread";

package/dist/features/messaging/components/message/MessageBody.d.ts

@@ -0,0 +1,33 @@
+import { Dispatch, SetStateAction } from "react";
+import type { ChatMessage, DefaultMessage, MessagePart } from "@/types";
+interface MessageBodyProps {
+    message: ChatMessage | DefaultMessage;
+    isToolMessage: boolean;
+    showToolMessages: boolean;
+    artifactToRender: unknown | null;
+    toolViewMode: "preview" | "expanded";
+    isToolStreaming: boolean;
+    contentParts: MessagePart[];
+    textContent: string;
+    imageParts: MessagePart[];
+    fileParts: MessagePart[];
+    interruptParts: MessagePart[];
+    isStreamingMessage: boolean;
+    defaultMessage: DefaultMessage | null;
+    handleFileClick: (event: MouseEvent, fp: any, index: number) => Promise<void> | void;
+    uploadingFiles: Record<number, boolean>;
+    handleInterruptApprove: (part: any) => Promise<void> | void;
+    handleInterruptReject: (part: any) => Promise<void> | void;
+    disableInterruptActions: boolean;
+    messageRole: string;
+    truncateUserMessages: boolean;
+    userMessagePreviewLength: number;
+    isUserExpanded: boolean;
+    setIsUserExpanded: Dispatch<SetStateAction<boolean>>;
+    isCompactLayout: boolean;
+    activeInterruptId: string | null;
+    activeInterruptValue?: unknown;
+    iconForeground: string;
+}
+export declare function MessageBody({ message, isToolMessage, showToolMessages, artifactToRender, toolViewMode, isToolStreaming, contentParts, textContent, imageParts, fileParts, interruptParts, isStreamingMessage, defaultMessage, handleFileClick, uploadingFiles, handleInterruptApprove, handleInterruptReject, disableInterruptActions, messageRole, truncateUserMessages, userMessagePreviewLength, isUserExpanded, setIsUserExpanded, isCompactLayout, activeInterruptId, activeInterruptValue, iconForeground, }: MessageBodyProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/messaging/components/message/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useFilePreview } from "./useFilePreview";

package/dist/features/messaging/components/message/index.d.ts

@@ -1,9 +1,14 @@
-export { ArtifactRenderer } from "./ArtifactRenderer";
+export { MessageComponent } from "./MessageComponent";
+export type { MessageComponentProps } from "./MessageComponent";
+export { MessageList } from "./MessageList";
+export type { MessageListProps, MessageListHandle } from "./MessageList";
+export { MessageRow, getMessageDomKey } from "./MessageRow";
+export type { MessageRowProps } from "./MessageRow";
+export { MessageBody } from "./MessageBody";
 export { PlotArtifact } from "./artifacts/PlotArtifact";
 export { ResearchTaskArtifact } from "./artifacts/ResearchTaskArtifact";
-export { InterruptPartRenderer } from "./InterruptPartRenderer";
-export { SimpleJsonView } from "./SimpleJsonView";
-export { StreamProgress } from "./StreamProgress";
-export { ToolComponent } from "./ToolComponent";
-export { useFilePreview } from "./useFilePreview";
-export { UserTextContent } from "./UserTextContent";
+export { ArtifactRenderer, InterruptPartRenderer, SimpleJsonView, StreamProgress, ToolComponent, ThinkingIndicator, UserTextContent, } from "./renderers";
+export { useFilePreview } from "./hooks";
+export { MarkdownContent } from "./markdown";
+export type { MarkdownContentProps } from "./markdown";
+export { FileViewerModal } from "./modals";

package/dist/features/messaging/components/{MarkdownContent.d.ts → message/markdown/MarkdownContent.d.ts}

@@ -1,5 +1,5 @@
 import React from 'react';
-interface MarkdownContentProps {
+export interface MarkdownContentProps {
     content: string;
     className?: string;
     allowHtml?: boolean;

package/dist/features/messaging/components/message/markdown/index.d.ts

@@ -0,0 +1,3 @@
+export { MarkdownContent } from "./MarkdownContent";
+export type { MarkdownContentProps } from "./MarkdownContent";
+export { marked } from "marked";

package/dist/features/messaging/components/message/modals/index.d.ts

@@ -0,0 +1 @@
+export { FileViewerModal } from "./FileViewerModal";

package/dist/features/messaging/components/message/renderers/ThinkingIndicator.d.ts

@@ -0,0 +1,3 @@
+export declare function ThinkingIndicator({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/features/messaging/components/message/renderers/index.d.ts

@@ -0,0 +1,7 @@
+export { ArtifactRenderer } from "./ArtifactRenderer";
+export { InterruptPartRenderer } from "./InterruptPartRenderer";
+export { SimpleJsonView } from "./SimpleJsonView";
+export { StreamProgress } from "./StreamProgress";
+export { ToolComponent } from "./ToolComponent";
+export { ThinkingIndicator } from "./ThinkingIndicator";
+export { UserTextContent } from "./UserTextContent";

package/dist/features/messaging/components/message/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./messageHelpers";
+export * from "./messageUtils";

package/dist/features/messaging/{utils → components/message/utils}/messageHelpers.d.ts

@@ -2,11 +2,12 @@
  * Shared helper utilities for chat message rendering and metadata parsing.
  */
 import type { ArtifactPreview, ChatMessage, DefaultMessage, MessagePart, PlotData } from "@/types";
-export declare function collectText(parts: MessagePart[]): string;
-export declare function extractToolMeta(message: ChatMessage): {
+export type ToolMeta = {
     name?: string;
     toolCallId?: string;
 };
+export declare function collectText(parts: MessagePart[]): string;
+export declare function extractToolMeta(message: ChatMessage): ToolMeta;
 export declare function normalizeInterruptId(id: unknown): string | null;
 export declare function stringifyTool(parts: MessagePart[]): string;
 export declare function getAgentNameFromMessage(m: ChatMessage): string | null;
@@ -26,3 +27,4 @@ export declare function createArtifactPreviewFromSource({ base64, url, formatHin
     };
 }): ArtifactPreview | null;
 export declare function createArtifactPreviewFromPlot(plot: PlotData): ArtifactPreview | null;
+export declare function getToolProgress(message: ChatMessage | DefaultMessage): unknown[];

package/dist/features/messaging/components/thread/index.d.ts

@@ -0,0 +1,4 @@
+export { ThreadManager, useThreadManagerViewState } from "./ThreadManager";
+export type { ThreadManagerProps, ThreadManagerView, ThreadManagerViewOption, ThreadManagerViewState, UseThreadManagerViewStateOptions, } from "./ThreadManager";
+export { ThreadListItem } from "./ThreadListItem";
+export type { ThreadListItemProps } from "./ThreadListItem";

package/dist/features/messaging/hooks/useParsedMessageContent.d.ts

@@ -0,0 +1,13 @@
+import type { ChatMessage, DefaultMessage, MessagePart } from "@/types";
+import { ToolMeta } from "@/features/messaging/components/message/utils";
+export interface ParsedMessageContent {
+    contentParts: MessagePart[];
+    textContent: string;
+    toolMeta: ToolMeta;
+    imageParts: MessagePart[];
+    fileParts: MessagePart[];
+    interruptParts: MessagePart[];
+    toolRaw: string;
+    isToolStreaming: boolean;
+}
+export declare function useParsedMessageContent(message: ChatMessage | DefaultMessage, defaultMessage: DefaultMessage | null): ParsedMessageContent;

package/dist/features/messaging/index.d.ts

@@ -1,12 +1 @@
-export * from "./components/ChatApp";
-export { ChatInput } from "./components/ChatInput";
-export type { ChatInputProps } from "./components/ChatInput";
-export { ChatInterface } from "./components/ChatInterface";
-export type { ChatInterfaceProps } from "./components/ChatInterface";
-export { MessageComponent } from "./components/MessageComponent";
-export type { MessageComponentProps } from "./components/MessageComponent";
-export { MessageList } from "./components/MessageList";
-export type { MessageListProps } from "./components/MessageList";
-export { MarkdownContent } from "./components/MarkdownContent";
-export { FileViewerModal } from "./components/FileViewerModal";
-export { ThreadManager } from "./components/ThreadManager";
+export * from "./components";

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

@@ -1,92 +1,6 @@
-/**
- * DEMO-SIMPLIFIED StreamingProvider
- *
- * This is a reduced version optimized for demo/development with ~50% fewer lines.
- *
- * REMOVED FOR SIMPLICITY:
- * - localStorage/sessionStorage caching (causes stale data bugs!)
- * - Complex cache eviction logic
- * - Thread persistence to localStorage
- * - Checkpoint persistence to localStorage (HOST RESPONSIBILITY)
- * - Resume/reconnection exponential backoff
- * - Token rotation debouncing
- * - History response caching layers
- *
- * KEPT (Essential):
- * - Thread management (load, create, delete, list)
- * - Message streaming with automatic URL sync (blocks during stream)
- * - Checkpoint navigation
- * - Auth token handling
- * - Event handling (stream, interrupts)
- *
- * KEY DESIGN: Host (MainLayout) is responsible for:
- * - Reading lastCheckpointId/Ns from localStorage on mount
- * - Passing it to ChatProviders as initialCheckpointId/Ns
- * - Syncing checkpoint changes back to localStorage
- *
- * Package handles:
- * - Never fetching history while streaming (blocks auto-load)
- * - Never updating URL/re-rendering while streaming
- * - Clean stream → URL sync transition
- *
- * RESULT: Much easier to debug, faster development, no stale cache issues
- */
-import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
-import type { TimelineCheckpoint } from "@/features/checkpoint/types";
-import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, SharedThreadSummary, ThreadSummary } from '@/types';
-import type { StreamContextValue, ThreadStateMetadata } from '@/features/core/types';
-import type { ToolEndEvent } from "@/features/streaming";
+import type { StreamContextValue } from '@/features/core/types';
+import type { ToolEndEvent } from '@/features/streaming';
 import { type ReactNode } from 'react';
-interface ThreadsContextValue {
-    threads: ThreadSummary[];
-    currentThreadId: string | null;
-    setCurrentThreadId: (id: string | null) => void;
-    isLoading: boolean;
-    error: string | null;
-    sharedThreads: SharedThreadSummary[];
-    isLoadingSharedThreads: boolean;
-    actions: {
-        createThread: (title?: string) => Promise<string | null>;
-        deleteThread: (threadId: string) => Promise<void>;
-        renameThread: (threadId: string, title: string) => Promise<void>;
-        refreshThreads: () => Promise<void>;
-        refreshSharedThreads: () => Promise<void>;
-        shareThread: (threadId: string, sharedWithUserId: string) => Promise<void>;
-        unshareThread: (threadId: string, shareId: string) => Promise<void>;
-    };
-    shareInFlight: boolean;
-    shareStatus: string | null;
-    clearShareStatus: () => void;
-}
-interface ThreadStateContextValue {
-    threadId: string | null;
-    messages: ChatMessage[];
-    interrupt: PendingInterrupt;
-    checkpoint: {
-        id: string | null;
-        namespace: string | null;
-    };
-    checkpoints: HydratedCheckpointSnapshot[];
-    checkpointIndex: CheckpointIndex;
-    timelineCheckpoints: TimelineCheckpoint[];
-    metadata: ThreadStateMetadata | null;
-    isLoading: boolean;
-    isHistoryLoading: boolean;
-    isLoadingCheckpoint: boolean;
-    error: string | null;
-    hasMore: boolean;
-    loadOlder: () => Promise<void>;
-    clearState: () => void;
-    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
-    setCurrentCheckpointId: (checkpointId: string | null, checkpointNs?: string | null) => void;
-    returnToLatest: () => Promise<void>;
-    loadThread: (threadId: string, checkpointId?: string, options?: {
-        clearProgress?: boolean;
-    }) => Promise<void>;
-    clearThread: () => Promise<void>;
-    respondToInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
-    messagePreviews: Map<string, string>;
-}
 interface StreamingProviderProps {
     children: ReactNode;
     initialThreadId?: string | null;
@@ -100,11 +14,6 @@ interface StreamingProviderProps {
     onToolEnd?: (event: ToolEndEvent) => void;
 }
 export declare function StreamingProvider({ children, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, onError, onAuthError, onThreadChange, onConnectionError, onToolEnd, }: StreamingProviderProps): import("react/jsx-runtime").JSX.Element;
-/**
-* Hook to check if the current component is within a StreamingProvider
- */
-export declare function useHasChatSession(): boolean;
-export declare function useThreads(): ThreadsContextValue;
-export declare function useThreadState(): ThreadStateContextValue;
 export declare function useStream(): StreamContextValue;
+export declare function useHasChatSession(): boolean;
 export {};

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

@@ -1,2 +1 @@
-export { StreamingProvider } from "./StreamingProvider";
-export { useStream, useThreads, useThreadState, useHasChatSession } from "./StreamingProvider";
+export { StreamingProvider, useStream, useHasChatSession } from "./StreamingProvider";

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

@@ -1,11 +1,15 @@
+import type { MutableRefObject } from "react";
 import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, SharedThreadSummary, ThreadSummary } from "@/types";
 import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
 import type { TimelineCheckpoint } from "@/features/checkpoint/types";
-import type { StreamContextValue, ThreadStateMetadata } from "@/features/core/types";
+import type { ThreadStateMetadata } from "@/features/core/types";
+import type { StateHistoryEvent, StreamEvent, ThreadInfoEvent } from "@/features/streaming";
 export interface ThreadsContextValue {
     threads: ThreadSummary[];
     currentThreadId: string | null;
+    currentThreadIdRef: MutableRefObject<string | null>;
     setCurrentThreadId: (id: string | null) => void;
+    addThreadFromEvent: (event: ThreadInfoEvent) => void;
     isLoading: boolean;
     error: string | null;
     sharedThreads: SharedThreadSummary[];
@@ -51,7 +55,10 @@ export interface ThreadStateContextValue {
     clearThread: () => Promise<void>;
     respondToInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
     messagePreviews: Map<string, string>;
+    /** @internal */ handleStateHistoryEvent: (event: StateHistoryEvent) => void;
+    /** @internal */ markSkipNextLoad: (threadId: string | null) => void;
+    /** @internal */ markStreamPendingThread: (threadId: string | null) => void;
+    /** @internal */ resetHistoryState: () => void;
+    /** @internal */ pushUser: (message: ChatMessage, editingMessageId?: string | null) => void;
+    /** @internal */ onEvent: (event: StreamEvent) => void;
 }
-export declare const ThreadContext: import("react").Context<ThreadsContextValue | null>;
-export declare const ThreadStateContext: import("react").Context<ThreadStateContextValue | null>;
-export declare const StreamContext: import("react").Context<StreamContextValue | null>;

package/dist/features/streaming/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./use-stream";
+export * from "./types";

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

@@ -0,0 +1,50 @@
+import { ChatRequest, HistoryPayload, StreamEvent } from "@/types";
+export type UseChatStreamOptions = {
+    baseUrl?: string;
+    streamPath?: string;
+    token?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    autoAppendAssistant?: boolean;
+};
+export type UseStreamApi = {
+    isStreaming: boolean;
+    error: string | null;
+    lastCheckpointId: string | null;
+    assistantText: string;
+    lastSeq: number;
+    connected: boolean;
+    stream: (req: ChatRequest, onEvent?: (ev: StreamEvent) => void, options?: {
+        onError?: (message: string) => void;
+        onOpen?: (info: {
+            threadId: string | null;
+            created: boolean;
+        }) => void;
+        onGap?: (gap: {
+            from: number;
+            to: number;
+        }) => void;
+        onClosed?: (info: {
+            reason: "complete" | "aborted" | "error";
+            lastSeq: number;
+            lastCheckpointId: string | null;
+            lastCheckpointNs: string | null;
+            lastStateHistory: HistoryPayload | null;
+            error?: string | null;
+        }) => void;
+        onConnectionError?: (message: string) => void;
+        onAuthError?: (message: string) => void;
+        onHeartbeat?: (event: Extract<StreamEvent, {
+            type: "heartbeat";
+        }>) => void;
+    }) => {
+        close: () => void;
+    };
+    stop: () => void;
+    clear: () => void;
+    setToken: (t: string | null) => void;
+};
+export type ActiveRunContext = {
+    threadId: string | null;
+    headers: Record<string, string>;
+};

package/dist/features/streaming/hooks/use-stream.d.ts

@@ -1,47 +1,2 @@
-import { ChatRequest, HistoryPayload, StreamEvent } from "@/types";
-export type UseChatStreamOptions = {
-    baseUrl?: string;
-    streamPath?: string;
-    token?: string;
-    headers?: Record<string, string>;
-    credentials?: RequestCredentials;
-    autoAppendAssistant?: boolean;
-};
-export type UseStreamApi = {
-    isStreaming: boolean;
-    error: string | null;
-    lastCheckpointId: string | null;
-    assistantText: string;
-    lastSeq: number;
-    connected: boolean;
-    stream: (req: ChatRequest, onEvent?: (ev: StreamEvent) => void, options?: {
-        onError?: (message: string) => void;
-        onOpen?: (info: {
-            threadId: string | null;
-            created: boolean;
-        }) => void;
-        onGap?: (gap: {
-            from: number;
-            to: number;
-        }) => void;
-        onClosed?: (info: {
-            reason: "complete" | "aborted" | "error";
-            lastSeq: number;
-            lastCheckpointId: string | null;
-            lastCheckpointNs: string | null;
-            lastStateHistory: HistoryPayload | null;
-            error?: string | null;
-        }) => void;
-        onConnectionError?: (message: string) => void;
-        onAuthError?: (message: string) => void;
-        onHeartbeat?: (event: Extract<StreamEvent, {
-            type: "heartbeat";
-        }>) => void;
-    }) => {
-        close: () => void;
-    };
-    stop: () => void;
-    clear: () => void;
-    setToken: (t: string | null) => void;
-};
+import type { UseChatStreamOptions, UseStreamApi } from "../utils/types";
 export declare function useStream(opts?: UseChatStreamOptions): UseStreamApi;

package/dist/features/streaming/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./utils";
 export * from "./contexts";
-export { useStream as useStreamingHook, type UseStreamApi, type UseChatStreamOptions } from "./hooks/use-stream";
-export { ChatProviders, type ChatProvidersProps } from "../core/contexts/providers/ChatProviders";
+export { useStream as useStreamingHook } from "./hooks/use-stream";
+export type { UseStreamApi, UseChatStreamOptions, ActiveRunContext, } from "./hooks/types";
+export * from "./utils";

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

@@ -1,4 +1,54 @@
 import type { MessagePart, HistoryPayload } from "@/types";
+import { ChatRequest } from "@/types";
+export type UseChatStreamOptions = {
+    baseUrl?: string;
+    streamPath?: string;
+    token?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    autoAppendAssistant?: boolean;
+};
+export type UseStreamApi = {
+    isStreaming: boolean;
+    error: string | null;
+    lastCheckpointId: string | null;
+    assistantText: string;
+    lastSeq: number;
+    connected: boolean;
+    stream: (req: ChatRequest, onEvent?: (ev: StreamEvent) => void, options?: {
+        onError?: (message: string) => void;
+        onOpen?: (info: {
+            threadId: string | null;
+            created: boolean;
+        }) => void;
+        onGap?: (gap: {
+            from: number;
+            to: number;
+        }) => void;
+        onClosed?: (info: {
+            reason: "complete" | "aborted" | "error";
+            lastSeq: number;
+            lastCheckpointId: string | null;
+            lastCheckpointNs: string | null;
+            lastStateHistory: HistoryPayload | null;
+            error?: string | null;
+        }) => void;
+        onConnectionError?: (message: string) => void;
+        onAuthError?: (message: string) => void;
+        onHeartbeat?: (event: Extract<StreamEvent, {
+            type: "heartbeat";
+        }>) => void;
+    }) => {
+        close: () => void;
+    };
+    stop: () => void;
+    clear: () => void;
+    setToken: (t: string | null) => void;
+};
+export type ActiveRunContext = {
+    threadId: string | null;
+    headers: Record<string, string>;
+};
 type ToolEventIdentity = {
     id: string;
     call_id?: string;

package/dist/features/thread/contexts/ThreadStateProvider.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { ThreadStateContextValue } from '@/features/streaming/contexts/types';
+interface ThreadStateProviderProps {
+    children: ReactNode;
+    initialThreadId?: string | null;
+    initialCheckpointId?: string | null;
+    initialCheckpointNs?: string | null;
+    autoLoadInitial?: boolean;
+    isStreaming: boolean;
+    onError?: (error: string) => void;
+}
+interface ThreadStateUpdater {
+    registerClearThread: (fn: ThreadStateContextValue['clearThread']) => void;
+    registerRespondToInterrupt: (fn: ThreadStateContextValue['respondToInterrupt']) => void;
+}
+export declare function useThreadState(): ThreadStateContextValue;
+export declare function useThreadStateUpdater(): ThreadStateUpdater;
+export declare function ThreadStateProvider({ children, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, isStreaming, onError, }: ThreadStateProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { ThreadsContextValue } from '@/features/streaming/contexts/types';
+export interface ThreadsProviderProps {
+    children: ReactNode;
+    initialThreadId?: string | null;
+    onError?: (error: string) => void;
+    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;

package/dist/features/thread/contexts/index.d.ts

@@ -0,0 +1,2 @@
+export { ThreadsProvider, useThreads } from './ThreadsProvider';
+export { ThreadStateProvider, useThreadState, useThreadStateUpdater } from './ThreadStateProvider';

package/dist/features/thread/index.d.ts

@@ -1,2 +1,3 @@
 export { useThreadsState } from "./hooks/useThreadsState";
 export { useThreadHistoryState } from "./hooks/useThreadHistoryState";
+export * from "./contexts";