teodor-new-chat-ui 4.3.596 → 4.3.598

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

@@ -6,7 +6,7 @@ declare const Command: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
     label?: string;
     shouldFilter?: boolean;
     filter?: (value: string, search: string, keywords?: string[]) => number;
@@ -22,7 +22,7 @@ declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<
     ref?: React.Ref<HTMLInputElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
     value?: string;
     onValueChange?: (search: string) => void;
 } & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
@@ -32,7 +32,7 @@ declare const CommandList: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
     label?: string;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
@@ -41,14 +41,14 @@ declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
     children?: React.ReactNode;
 } & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
     heading?: React.ReactNode;
     value?: string;
     forceMount?: boolean;
@@ -57,7 +57,7 @@ declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<R
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
     alwaysRender?: boolean;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
@@ -66,7 +66,7 @@ declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "disabled" | "onSelect"> & {
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "onSelect" | "disabled"> & {
     disabled?: boolean;
     onSelect?: (value: string) => void;
     value?: string;

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<HTMLAnchorElement | HTMLElement | HTMLDivElement | HTMLButtonElement | HTMLSpanElement | HTMLParagraphElement | HTMLObjectElement | HTMLDataElement | HTMLSourceElement | HTMLLinkElement | HTMLHeadElement | HTMLBodyElement | HTMLMapElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBRElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDialogElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLFormElement | HTMLHeadingElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLImageElement | HTMLInputElement | HTMLLabelElement | HTMLLegendElement | HTMLLIElement | HTMLMetaElement | HTMLMeterElement | HTMLOListElement | HTMLOptGroupElement | HTMLOptionElement | HTMLOutputElement | HTMLPreElement | HTMLProgressElement | HTMLScriptElement | HTMLSelectElement | HTMLSlotElement | HTMLStyleElement | HTMLTableElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTemplateElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTitleElement | HTMLTableRowElement | HTMLTrackElement | HTMLUListElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLAnchorElement | HTMLElement | HTMLDivElement | HTMLObjectElement | HTMLSourceElement | HTMLDataElement | HTMLHeadElement | HTMLLinkElement | HTMLBodyElement | HTMLMapElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBRElement | HTMLButtonElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDialogElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLFormElement | HTMLHeadingElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLImageElement | HTMLInputElement | HTMLLabelElement | HTMLLegendElement | HTMLLIElement | HTMLMetaElement | HTMLMeterElement | HTMLOListElement | HTMLOptGroupElement | HTMLOptionElement | HTMLOutputElement | HTMLParagraphElement | HTMLPreElement | HTMLProgressElement | HTMLScriptElement | HTMLSelectElement | HTMLSlotElement | HTMLSpanElement | HTMLStyleElement | HTMLTableElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTemplateElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTitleElement | HTMLTableRowElement | HTMLTrackElement | HTMLUListElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
     className?: string | undefined;
     collapsedSize?: number | undefined;
     collapsible?: boolean | undefined;

package/dist/features/{chat/components/ChatInterface → conversation/components}/ChatInterface.d.ts

@@ -4,11 +4,11 @@
  * Relies on the split context hooks (useThreads/useMessages/useStream/useApi).
  */
 import type { ChatMessage } from "@/types";
-import { type MessageComponentProps, type ToolConfig, type ToolRendererMap, type ToolArtifactRendererMap } from "../Message";
+import type { MessageComponentProps } from "./MessageComponent";
+import type { ToolConfig, ToolRendererMap, ToolArtifactRendererMap } from "./ToolContent";
 export interface ChatInterfaceProps {
     className?: string;
     placeholder?: string;
-    autoFocus?: boolean;
     maxHeight?: string;
     /** Debounce (ms) used for buffering mid-stream markdown updates */
     streamingDebounceMs?: number;
@@ -40,5 +40,5 @@ export interface ChatInterfaceProps {
     }) => void;
     onError?: (error: string) => void;
 }
-export declare function ChatInterface({ className, placeholder, autoFocus, maxHeight, streamingDebounceMs, followNewMessages, enableFileUpload, enableExcelUpload, enableMessageEditing, showToolMessages, toolConfig, toolRenderers, toolArtifactRenderers, payloadExtras, customStyles, messageCustomStyles, onMessageSent, onExcelUploadSuccess, onError, }: ChatInterfaceProps): import("react/jsx-runtime").JSX.Element;
-export type { ToolRendererMap, ToolArtifactRendererMap, ToolArtifactRendererContext, } from "../Message/ToolContent";
+export declare function ChatInterface({ className, placeholder, maxHeight, streamingDebounceMs, followNewMessages, enableFileUpload, enableExcelUpload, enableMessageEditing, showToolMessages, toolConfig, toolRenderers, toolArtifactRenderers, payloadExtras, customStyles, messageCustomStyles, onMessageSent, onExcelUploadSuccess, onError, }: ChatInterfaceProps): import("react/jsx-runtime").JSX.Element;
+export type { ToolRendererMap, ToolArtifactRendererMap, ToolArtifactRendererContext, } from "./ToolContent";

package/dist/features/{chat/components/Message → conversation/components}/MessageComponent.d.ts

@@ -2,11 +2,12 @@
  * Message Component - With truncatable tool messages and responsive design
  */
 import type { ChatMessage, RespondToInterruptOptions } from "@/types";
-import type { CheckpointMeta, EditMeta } from "@/features/checkpoint/types";
+import type { CheckpointMeta, EditMeta } from "@/features/persistence";
 import type { ToolConfig } from "./ToolContent";
 export interface MessageComponentProps {
     message: ChatMessage;
     messageIndex: number;
+    allMessages?: ChatMessage[];
     isStreamingMessage?: boolean;
     /** ms to wait for quiet before rendering streaming markdown updates */
     streamingDebounceMs?: number;

package/dist/features/{chat/components/Message → conversation/components}/MessageList.d.ts

@@ -1,6 +1,6 @@
 import type { ChatMessage, RespondToInterruptOptions, PendingInterrupt } from "@/types";
-import type { EditMeta, TimelineCheckpoint } from "@/features/checkpoint/types";
-import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
+import type { EditMeta, TimelineCheckpoint } from "@/features/persistence/checkpoints/types";
+import type { CheckpointIndex } from "@/features/persistence/checkpoints/utils/checkpointIndex";
 import React from "react";
 import type { MessageComponentProps } from "./MessageComponent";
 import type { ToolConfig } from "./ToolContent";

package/dist/features/{chat/components/Message → conversation/components}/MessageRow.d.ts

@@ -1,6 +1,6 @@
 import type { ChatMessage, RespondToInterruptOptions } from "@/types";
-import type { EditMeta } from "@/features/checkpoint/types";
-import { type CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
+import type { EditMeta } from "@/features/persistence/checkpoints/types";
+import { type CheckpointIndex } from "@/features/persistence/checkpoints/utils/checkpointIndex";
 import type { MessageComponentProps } from "./MessageComponent";
 import React from "react";
 import type { ToolConfig } from "./ToolContent";
@@ -8,7 +8,7 @@ export declare const getMessageDomKey: (message: ChatMessage | undefined, index:
 export interface MessageRowProps {
     message: ChatMessage;
     index: number;
-    isStreaming: boolean;
+    allMessages?: ChatMessage[];
     streamingAssistantId: string | null;
     streamingDebounceMs?: number;
     layoutSize: "phone" | "tablet" | "desktop" | "half-screen";

package/dist/features/{chat/components/Message → conversation/components}/ToolContent.d.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage, MessageArtifact } from "@/types";
 import type { ReactNode } from "react";
-import { type ToolPayloadResult } from "@/features/chat/components/Message/hooks";
-import type { ToolMeta } from "@/features/chat/components/Message/utils/messageHelpers";
+import { type ToolPayloadResult } from "./hooks/useToolPayload";
+import type { ToolMeta } from "./utils/messageHelpers";
 export interface ToolRendererContext {
     message: ChatMessage;
     toolMeta: ToolMeta;

package/dist/features/{chat/components/Message → conversation/components}/hooks/useParsedMessageContent.d.ts

@@ -1,5 +1,5 @@
 import type { ChatMessage, MessagePart } from "@/types";
-import { ToolMeta } from "@/features/chat/components/Message/utils";
+import { ToolMeta } from "../utils/messageHelpers";
 export interface ParsedMessageContent {
     contentParts: MessagePart[];
     textContent: string;

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

@@ -0,0 +1,12 @@
+export { ChatApp } from "./ChatApp";
+export { ChatInterface } from "./ChatInterface";
+export { ChatInput } from "./ChatInput";
+export { ChatWidget } from "./ChatWidget";
+export { NewChatButton } from "./NewChatButton";
+export { ChatInputRow } from "./ChatInputRow";
+export { MessageList } from "./MessageList";
+export { default as MessageComponent } from "./MessageComponent";
+export { MessageRow, getMessageDomKey } from "./MessageRow";
+export { ToolContent } from "./ToolContent";
+export { MessageContent } from "./renderers/MessageContent";
+export * from "./renderers";

package/dist/features/{chat/components/Message → conversation/components}/renderers/MessageContent.d.ts

@@ -1,9 +1,9 @@
 import { MouseEvent as ReactMouseEvent } from "react";
-import type { ChatMessage, MessagePart } from "@/types";
-import type { InterruptPart, InterruptAlternative } from "@/features/chat/types/models";
+import type { ChatMessage, MessagePart, InterruptPart, InterruptAlternative } from "@/types";
 import type { ToolConfig } from "../ToolContent";
 export interface MessageContentProps {
     message: ChatMessage;
+    allMessages?: ChatMessage[];
     isToolMessage: boolean;
     showToolMessages: boolean;
     toolViewMode: "preview" | "expanded";
@@ -32,7 +32,6 @@ export interface MessageContentProps {
     handleInterruptReject?: () => void;
     handleInterruptAlternative?: (part: unknown, alternative?: InterruptAlternative) => void;
     disableInterruptActions?: boolean;
-    isInterruptMessage: boolean;
 }
-export declare function MessageContent({ message, isToolMessage, showToolMessages, toolViewMode, toolExpandable, isToolStreaming, contentParts, textContent, imageParts, fileParts, interruptPart, isStreamingMessage, streamingDebounceMs, enableStreamingMarkdownBuffer, renderStreamingMarkdown, handleFileClick, uploadingFiles, messageRole, truncateUserMessages, userMessagePreviewLength, isUserExpanded, setIsUserExpanded, isCompactLayout, iconForeground, toolConfig, handleInterruptApprove, handleInterruptReject, handleInterruptAlternative, disableInterruptActions, isInterruptMessage, }: MessageContentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function MessageContent({ message, allMessages, isToolMessage, showToolMessages, toolViewMode, toolExpandable, isToolStreaming, contentParts, textContent, imageParts, fileParts, interruptPart, isStreamingMessage, streamingDebounceMs, enableStreamingMarkdownBuffer, renderStreamingMarkdown, handleFileClick, uploadingFiles, messageRole, truncateUserMessages, userMessagePreviewLength, isUserExpanded, setIsUserExpanded, isCompactLayout, iconForeground, toolConfig, handleInterruptApprove, handleInterruptReject, handleInterruptAlternative, disableInterruptActions, }: MessageContentProps): import("react/jsx-runtime").JSX.Element | null;
 export default MessageContent;

package/dist/features/{chat/components/Message → conversation/components}/renderers/MessageHeader.d.ts

@@ -1,4 +1,4 @@
-import type { ToolMeta } from "@/features/chat/components/Message/utils/messageHelpers";
+import type { ToolMeta } from "../utils/messageHelpers";
 export interface MessageHeaderProps {
     showTimestamp: boolean;
     showAgentName: boolean;

package/dist/features/conversation/components/renderers/artifacts/ArtifactProgress.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Artifact Progress Component
+ *
+ * Shows real-time progress for streaming artifacts.
+ * Displays status, progress bar, and partial data.
+ */
+import type { MessageArtifact } from "@/types";
+interface ArtifactProgressProps {
+    artifact: MessageArtifact | null | undefined;
+    showPartialData?: boolean;
+}
+export declare function ArtifactProgress({ artifact, showPartialData }: ArtifactProgressProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/conversation/components/renderers/artifacts/index.d.ts

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

package/dist/features/{chat/components/Message → conversation/components}/renderers/index.d.ts

@@ -1,6 +1,7 @@
 export { ArtifactRenderer } from "./tool/artifacts/ArtifactRenderer";
-export { SimpleJsonView } from "./tool/content/SimpleJsonView";
-export { StreamProgress } from "./tool/content/StreamProgress";
+export { ArtifactProgress } from "./artifacts/ArtifactProgress";
+export { SimpleJsonView } from "./content/SimpleJsonView";
+export { ToolProgress } from "./tool/content/ToolProgress";
 export { InterruptPartRenderer } from "./user/InterruptPartRenderer";
 export { ThinkingIndicator } from "./shared/ThinkingIndicator";
 export { UserTextContent } from "./user/UserTextContent";

package/dist/features/{chat/components/Message → conversation/components}/renderers/tool/artifacts/ArtifactRenderer.d.ts

@@ -6,7 +6,7 @@
  */
 import type { MessageArtifact } from "@/types";
 export interface ArtifactRendererProps {
-    artifact: MessageArtifact | any;
+    artifact: MessageArtifact | null | undefined;
     idx?: number;
 }
 /**

package/dist/features/conversation/components/renderers/tool/content/ToolProgress.d.ts

@@ -0,0 +1,11 @@
+import type { ChatMessage } from "@/types";
+import type { ToolConfig } from "../../../ToolContent";
+interface ToolProgressProps {
+    message: ChatMessage;
+    allMessages?: ChatMessage[];
+    isStreaming?: boolean;
+    viewMode?: "preview" | "expanded";
+    toolConfig?: ToolConfig;
+}
+export declare function ToolProgress({ message, allMessages, isStreaming, toolConfig, }: ToolProgressProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/{chat/components/Message → conversation/components}/renderers/user/InterruptPartRenderer.d.ts

@@ -7,7 +7,7 @@ export declare function InterruptPartRenderer({ interruptPart, onApprove, onReje
     interruptPart: {
         type: "interrupt";
         title?: string;
-        id?: string;
+        id?: string | null;
     };
     onApprove: (interruptPart: any) => void;
     onReject: (interruptPart: any) => void;

package/dist/features/conversation/components/utils/artifactUtils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Artifact Utilities
+ *
+ * Helper functions for working with artifacts, including metadata handling
+ * and streaming updates.
+ */
+import type { MessageArtifact, ChatMessage } from "@/types";
+export interface ArtifactMetadata {
+    id: string;
+    type: string;
+    created_at: string;
+    updated_at?: string;
+    status?: "pending" | "in_progress" | "completed" | "failed";
+    progress?: number;
+    error?: string;
+}
+export interface ArtifactWithMetadata extends MessageArtifact {
+    metadata: ArtifactMetadata;
+}
+/**
+ * Extract artifact metadata from a message
+ */
+export declare function getArtifactMetadata(message: ChatMessage): ArtifactMetadata | null;
+/**
+ * Check if an artifact is streaming (has progress < 100)
+ */
+export declare function isArtifactStreaming(artifact: MessageArtifact | undefined): boolean;
+/**
+ * Update artifact metadata during streaming
+ */
+export declare function updateArtifactMetadata(message: ChatMessage, updates: Partial<ArtifactMetadata>): ChatMessage;
+/**
+ * Find a message by artifact ID
+ */
+export declare function findMessageByArtifactId(messages: ChatMessage[], artifactId: string): ChatMessage | null;

package/dist/features/conversation/components/utils/messageHelpers.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared helper utilities for chat message rendering and metadata parsing.
+ */
+import type { PlotData, ArtifactPreview, ChatMessage, MessagePart } from "@/types";
+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;
+export declare function messageSignature(message: ChatMessage): string;
+export declare function normalizeMimeType(formatHint?: string): string;
+export declare function buildLabelParts(extras?: {
+    plotId?: string;
+    artifactId?: string;
+}): string[];
+export declare function createArtifactPreviewFromSource({ base64, url, formatHint, extras, }: {
+    base64?: string;
+    url?: string;
+    formatHint?: string;
+    extras?: {
+        plotId?: string;
+        artifactId?: string;
+    };
+}): ArtifactPreview | null;
+export declare function createArtifactPreviewFromPlot(plot: PlotData): ArtifactPreview | null;
+export declare function getToolProgress(message: ChatMessage): unknown[];
+/**
+ * Check if an assistant message contains ONLY tool_call parts (no text content).
+ * These messages should be hidden from the main list and their tool execution
+ * should be shown nested within the next assistant message with text.
+ */
+export declare function isAssistantMessageWithOnlyToolCalls(message: ChatMessage): boolean;
+/**
+ * Check if a message should be hidden from the main message list.
+ * This includes:
+ * - Tool messages (role: "tool")
+ * - Assistant messages with only tool_call parts (no text)
+ */
+export declare function shouldHideMessageFromList(message: ChatMessage): boolean;
+export type ToolExecutionEntry = {
+    type: "tool.start" | "tool.end";
+    toolName: string;
+    toolCallId: string;
+    content?: string;
+    timestamp?: string;
+    output?: unknown;
+    artifact?: unknown;
+};
+/**
+ * Build a tool execution timeline from message history.
+ * This matches assistant messages with tool_call parts to their corresponding
+ * tool response messages, creating a timeline similar to streaming events.
+ *
+ * @param messages - Full message list including tool messages
+ * @param currentMessageId - ID of the current assistant message to build timeline for
+ * @returns Array of tool execution entries (start/end pairs)
+ */
+export declare function buildToolExecutionTimeline(messages: ChatMessage[], currentMessageId: string): ToolExecutionEntry[];

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

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

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

@@ -0,0 +1,73 @@
+import type { ChatMessage } from "@/types";
+import type { PendingInterrupt } from "@/types";
+import type { StreamEvent } from "@/types/domain/streaming";
+export interface MessagesState {
+    messages: ChatMessage[];
+    assemblingId: string | null;
+    lastCheckpointId: string | null;
+    lastCheckpointNs: string | null;
+    pendingInterrupt: PendingInterrupt;
+    messagesStreamMeta?: Record<string, {
+        lastSeq?: number | null;
+        lastText?: string;
+    }>;
+    values: Record<string, unknown>;
+}
+export type MessagesAction = {
+    type: "reset";
+    payload?: {
+        messages?: ChatMessage[];
+    };
+} | {
+    type: "seed";
+    payload: {
+        messages: ChatMessage[];
+        checkpointId?: string | null;
+        checkpointNs?: string | null;
+        pendingInterrupt?: PendingInterrupt;
+    };
+} | {
+    type: "prepend";
+    payload: {
+        messages: ChatMessage[];
+    };
+} | {
+    type: "user_message";
+    payload: {
+        message: ChatMessage;
+        editingMessageId?: string | null;
+    };
+} | {
+    type: "event";
+    payload: {
+        ev: StreamEvent;
+    };
+} | {
+    type: "batch";
+    payload: {
+        events: StreamEvent[];
+    };
+} | {
+    type: "interrupt_response";
+    payload: {
+        interruptId: string;
+    };
+};
+export declare const initialMessagesState: MessagesState;
+export declare function messagesReducer(state: MessagesState, action: MessagesAction): MessagesState;
+export declare function useMessagesReducer(initial?: ChatMessage[]): {
+    readonly reset: (messages?: ChatMessage[]) => void;
+    readonly seed: (messages: ChatMessage[], opts?: {
+        checkpointId?: string | null;
+        checkpointNs?: string | null;
+        pendingInterrupt?: {
+            id: string;
+            value: any;
+        } | null;
+    }) => void;
+    readonly prepend: (messages: ChatMessage[]) => void;
+    readonly pushUser: (message: ChatMessage, editingMessageId?: string | null) => void;
+    readonly onEvent: (ev: StreamEvent) => void;
+    readonly state: MessagesState;
+    readonly dispatch: import("react").Dispatch<MessagesAction>;
+};

package/dist/features/{chat → conversation}/hooks/useChatController.d.ts

@@ -48,5 +48,5 @@ export declare function useChatController({ submit, chatRequest, lastCheckpointI
     startEditing: (messageId: string, content: string, meta?: EditContextMeta) => void;
     cancelEditing: () => void;
     handleRegenerateCb: (messageIndex: number) => void;
-    displayMessages: ChatMessage[];
+    displayMessages: ChatMessage[] | undefined;
 };

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

@@ -0,0 +1,43 @@
+import type { ChatApi } from "@/shared/core";
+import type { StateHistoryEvent } from "@/features/streaming";
+import type { ChatMessage, HydratedCheckpointSnapshot } from "@/types";
+import type { TimelineCheckpoint } from "@/features/persistence/checkpoints/types";
+import type { PendingInterrupt } from "@/types";
+import type { CheckpointIndex } from "@/features/persistence/checkpoints/utils/checkpointIndex";
+interface UseThreadHistoryStateOptions {
+    api: ChatApi;
+    seed: (messages: ChatMessage[], opts?: {
+        checkpointId?: string | null;
+        checkpointNs?: string | null;
+        pendingInterrupt?: PendingInterrupt;
+    }) => void;
+    onError?: (msg: string) => void;
+    currentThreadId: string | null;
+    initialThreadId?: string | null;
+    initialCheckpointId?: string | null;
+    initialCheckpointNs?: string | null;
+    autoLoadInitial?: boolean;
+    isStreaming: boolean;
+    getMessages: () => ChatMessage[];
+}
+interface ThreadHistoryResult {
+    threadCheckpoints: HydratedCheckpointSnapshot[];
+    threadTimeline: TimelineCheckpoint[];
+    checkpointIndex: CheckpointIndex;
+    isLoadingThread: boolean;
+    isLoadingCheckpoint: boolean;
+    threadStateError: string | null;
+    loadThread: (threadId: string, checkpointId?: string | null, options?: {
+        clearProgress?: boolean;
+    }) => Promise<void>;
+    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
+    setCurrentCheckpointId: (checkpointId: string | null, checkpointNs?: string | null) => void;
+    returnToLatest: () => Promise<void>;
+    handleStateHistoryEvent: (event: StateHistoryEvent) => void;
+    markSkipNextLoad: (threadId: string | null) => void;
+    markStreamPendingThread: (threadId: string | null) => void;
+    resetHistoryState: () => void;
+    clearState: () => void;
+}
+export declare function useThreadHistoryState({ api, seed, onError, currentThreadId, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, isStreaming, getMessages, }: UseThreadHistoryStateOptions): ThreadHistoryResult;
+export {};

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

@@ -0,0 +1,40 @@
+import { type MutableRefObject } from 'react';
+import type { ChatApi } from "@/shared/core";
+import type { ThreadInfoEvent } from '@/features/streaming';
+import type { ProjectInfo, SharedThreadSummary, ThreadSummary } from '@/types';
+interface ThreadActions {
+    createThread: (title?: string, project?: {
+        id: string;
+        name?: string;
+    } | ProjectInfo | null) => 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>;
+}
+interface UseThreadsStateOptions {
+    api: ChatApi;
+    initialThreadId?: string | null;
+    onError?: (error: string) => void;
+    onThreadChange?: (threadId: string | null) => void;
+    onCurrentThreadDeleted?: () => void;
+}
+export interface UseThreadsStateResult {
+    threads: ThreadSummary[];
+    currentThreadId: string | null;
+    currentThreadIdRef: MutableRefObject<string | null>;
+    setCurrentThreadId: (id: string | null) => void;
+    isLoadingThreads: boolean;
+    threadsError: string | null;
+    sharedThreads: SharedThreadSummary[];
+    isLoadingSharedThreads: boolean;
+    actions: ThreadActions;
+    addThreadFromEvent: (threadInfo: ThreadInfoEvent) => void;
+    shareInFlight: boolean;
+    shareStatus: string | null;
+    clearShareStatus: () => void;
+}
+export declare function useThreadsState({ api, initialThreadId, onError, onThreadChange, onCurrentThreadDeleted, }: UseThreadsStateOptions): UseThreadsStateResult;
+export {};

package/dist/features/{chat → conversation}/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./components";
-export * from "./types";
 export * from "./hooks";
+export * from "./contexts";

package/dist/features/persistence/checkpoints/types/models.d.ts

@@ -0,0 +1,53 @@
+import type { ChatMessage } from "@/types";
+import type { PendingInterrupt, PregelTask } from "@/types/core/models";
+/**
+ * Checkpoint domain models representing LangGraph snapshots and history payloads.
+ */
+export interface CheckpointSnapshot {
+    id?: string;
+    threadId?: string;
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+    values?: Record<string, unknown>;
+    next?: string[] | string | null;
+    config?: Record<string, unknown>;
+    metadata?: {
+        source?: string;
+        step?: number;
+        writes?: Record<string, unknown>;
+        execution_time?: number;
+        [key: string]: unknown;
+    };
+    tasks?: PregelTask[];
+    interrupts?: unknown[];
+    interrupt?: PendingInterrupt;
+    created_at?: string;
+    createdAt?: string;
+    parentConfig?: Record<string, unknown>;
+    parent_config?: Record<string, unknown>;
+}
+export interface HydratedCheckpointSnapshot {
+    checkpointId: string | null;
+    checkpointNs?: string | null;
+    parentId?: string | null;
+    createdAt: string;
+    messages?: ChatMessage[];
+    nextCursor?: string | null;
+    nextCursorNs?: string | null;
+    interrupt?: PendingInterrupt;
+    metadata?: {
+        step?: number | null;
+        source?: string | null;
+        [key: string]: unknown;
+    } | null;
+    config?: Record<string, unknown> | null;
+    parentConfig?: Record<string, unknown> | null;
+    next?: string[] | string | null;
+    tasks?: PregelTask[] | null;
+    values?: Record<string, unknown>;
+}
+export interface HistoryPayload {
+    version: string;
+    threadId: string;
+    checkpoints: CheckpointSnapshot[];
+}

package/dist/features/{checkpoint → persistence/checkpoints}/utils/messagePreviews.d.ts

@@ -1,4 +1,4 @@
-import type { HydratedCheckpointSnapshot } from '@/features/checkpoint/types';
+import type { HydratedCheckpointSnapshot } from '@/features/persistence/checkpoints/types';
 import type { ChatMessage } from '@/types';
 export declare function getPreviewForMessage(message: ChatMessage): string;
 /**

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

@@ -0,0 +1 @@
+export * from "./checkpoints";

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

@@ -1,5 +1,5 @@
-import type { StreamContextValue } from '@/shared/core/types';
-import type { ToolEndEvent } from '@/features/streaming';
+import type { StreamContextValue } from '@/types/core';
+import type { ToolEndEvent } from "@/types/domain/streaming";
 import { type ReactNode } from 'react';
 interface StreamingProviderProps {
     children: ReactNode;