@teodorruskvi/chat-core 0.1.2

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

@@ -0,0 +1,41 @@
+import React from "react";
+import type { ChatMessage, RespondToInterruptOptions, ToolConfig, PendingInterrupt } from "@/types";
+import type { MessageBubbleProps } from "../messages/components/MessageBubble";
+import type { EditMeta } from "@/features/persistence/checkpoints/types";
+import type { CheckpointIndex } from "@/features/persistence/checkpoints/utils/checkpointIndex";
+import type { ToolCallWithResult } from "@/types";
+export interface ChatUIContextValue {
+    layoutSize: "phone" | "tablet" | "desktop" | "half-screen";
+    customStyles: {
+        container?: string;
+        messagesArea?: string;
+        inputArea?: string;
+        sendButton?: string;
+        textarea?: string;
+        moreButton?: string;
+    };
+    messageCustomStyles?: (message: ChatMessage) => MessageBubbleProps["customStyles"] | undefined;
+    renderArtifactsInline: boolean;
+    showThinkingIndicator: boolean;
+    enableMessageEditing: boolean;
+    editingMessageId: string | null;
+    showToolMessages: boolean;
+    followNewMessages: boolean;
+    streamingDebounceMs: number;
+    toolConfig?: ToolConfig;
+    selectedToolCall?: ToolCallWithResult | null;
+    onSelectToolCall?: (toolCall: ToolCallWithResult | null) => void;
+    checkpointIndex?: CheckpointIndex;
+    activeCheckpointId?: string | null;
+    onSelectCheckpoint?: (checkpointId: string | null, parentCheckpointId?: string | null, isLatest?: boolean) => Promise<void> | void;
+    pendingInterrupt: PendingInterrupt | null;
+    onEdit: (messageId: string, content: string, meta?: EditMeta) => void;
+    onRegenerate: (messageIndex: number) => void;
+    onCancelEdit: () => void;
+    getInterruptOptions?: (message: ChatMessage) => RespondToInterruptOptions | undefined;
+}
+export interface ChatUIProviderProps extends ChatUIContextValue {
+    children: React.ReactNode;
+}
+export declare function ChatUIProvider({ children, ...value }: ChatUIProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useChatUI(): ChatUIContextValue;

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

@@ -0,0 +1,24 @@
+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(options: {
+    optional: true;
+}): ThreadStateContextValue | null;
+export declare function useThreadState(options?: {
+    optional?: false;
+}): 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/conversation/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/conversation/contexts/index.d.ts

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

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

@@ -0,0 +1,22 @@
+import type { ChatMessage } from "@/types";
+import type { StreamEvent } from "@/types/domain/streaming";
+import type { MessagesState, MessagesAction } 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 reset: (messages?: ChatMessage[]) => void;
+    readonly seed: (messages: ChatMessage[], opts?: {
+        checkpointId?: string | null;
+        checkpointNs?: string | null;
+        pendingInterrupt?: {
+            id: string;
+            value: 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;
+    readonly dispatch: import("react").Dispatch<MessagesAction>;
+};

package/dist/features/conversation/contexts/reducers/utils/reducerUtils.d.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage, MessagePart } from "@/types";
+export declare function sanitizeHistory(messages: ChatMessage[]): ChatMessage[];
+export declare function findMessageById(messages: ChatMessage[], id: string): ChatMessage | null;
+export declare function insertOrReplaceMessage(messages: ChatMessage[], message: ChatMessage): ChatMessage[];
+export declare function replaceMessageAtIndex(messages: ChatMessage[], index: number, message: ChatMessage): ChatMessage[];
+export declare function findLastAssistantId(messages: ChatMessage[]): string | null;
+export declare function getFullTextFromParts(parts: MessagePart[]): string;
+export declare function mergePartsWithMeta(baseParts: MessagePart[], deltaParts: MessagePart[], metaIn: {
+    lastSeq?: number | null;
+    lastText?: string;
+}, seq: number | null): {
+    newParts: MessagePart[];
+    newMeta: {
+        lastSeq?: number | null;
+        lastText?: string;
+    };
+    changed: boolean;
+};
+export declare function computeSuffix(existing: string, incoming: string): string;
+export declare function stampLastAssistantCheckpoint(messages: ChatMessage[], checkpointId: string, checkpointNs?: string | null): ChatMessage[];
+export declare function nameFromModel(model?: string): string | null;

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

@@ -0,0 +1,7 @@
+export { useFilePreview } from "./useFilePreview";
+export { useParsedMessageContent } from "./useParsedMessageContent";
+export { useToolPayload, type ToolPayloadResult, } from "../messages/hooks/useToolPayload";
+export { useChatController } from "./useChatController";
+export { useChatSession } from "./useChatSession";
+export { useThreadsState } from "./useThreadsState";
+export { useThreadHistoryState } from "./useThreadHistoryState";

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

@@ -0,0 +1,50 @@
+import { type ChatRequest, type ProjectInfo, type ChatMessage, type StreamSubmitPayload, type StreamCallbacks, type MessagePart, type StreamEvent } from "@/types";
+export type EditContextMeta = {
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+};
+/**
+ * Options for sending a message via handleSendMessage.
+ */
+export interface SendMessageOptions {
+    /** Files to upload (will be converted to contentParts after upload) */
+    files?: File[];
+    /** Pre-built content parts (e.g., already-uploaded documents with URLs) */
+    contentParts?: MessagePart[];
+}
+export interface UseChatControllerProps {
+    submit: (payload: StreamSubmitPayload, callbacks?: StreamCallbacks) => Promise<void>;
+    chatRequest: ChatRequest;
+    lastCheckpointId: string | null;
+    lastCheckpointNs: string | null;
+    onMessageSent?: (message: string) => void;
+    onExcelUploadSuccess?: (payload: {
+        file: File;
+    }) => void;
+    onError?: (error: string) => void;
+    enableMessageEditing?: boolean;
+    messages: ChatMessage[];
+    setPendingAssistantResponse: (pending: boolean) => void;
+    project?: ProjectInfo | null;
+    /** Optional callback for stream events */
+    onEvent?: (event: StreamEvent) => void;
+    /** The active thread ID for draft isolation */
+    threadId?: string | null;
+}
+export declare function useChatController({ submit, chatRequest, lastCheckpointId, lastCheckpointNs, onMessageSent, onExcelUploadSuccess, onError, enableMessageEditing, messages, setPendingAssistantResponse, project, onEvent, threadId, }: UseChatControllerProps): {
+    editingMessageId: string | null;
+    editingInitialValue: string;
+    inputError: string | null;
+    setInputError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    dismissError: boolean;
+    setDismissError: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    composerValue: string;
+    handleComposerChange: (text: string) => void;
+    handleSendMessage: (text: string, optionsOrFiles?: SendMessageOptions | File[]) => Promise<void>;
+    handleQuickPrompt: (prompt: string, isComposerDisabled: boolean) => void;
+    handleExcelUpload: (file: File) => Promise<void>;
+    startEditing: (messageId: string, content: string, meta?: EditContextMeta) => void;
+    cancelEditing: () => void;
+    handleRegenerateCb: (messageIndex: number) => void;
+    displayMessages: any[];
+};

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

@@ -0,0 +1,49 @@
+type UseChatSessionOptions = string | {
+    threadId?: string;
+} | undefined;
+export declare function useChatSession(options?: UseChatSessionOptions): {
+    threadId: string | null;
+    messages: any[];
+    isLoading: boolean;
+    isHistoryLoading: boolean;
+    error: string | null;
+    values: Record<string, unknown>;
+    metadata: {
+        assemblingMessageId: string | null;
+    } | undefined;
+    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
+    returnToLatest: () => Promise<void>;
+    checkpoint: {
+        id: string | null;
+        namespace: string | null;
+    } | null;
+    checkpoints: import("../../../types").HydratedCheckpointSnapshot[];
+    checkpointIndex: import("../../persistence/checkpoints/utils/checkpointIndex").CheckpointIndex | {
+        timeline: never[];
+        messagePreviews: {};
+    };
+    interrupt: {
+        id: string;
+        value: unknown;
+        alternatives?: import("../../../types").InterruptAlternative[];
+    } | null;
+    respondToInterrupt: (approved: boolean, value?: unknown, options?: any) => Promise<void>;
+    isStreaming: boolean;
+    activeMessageId: string | null;
+    connectionState: string;
+    streamingAssistantId: string | null;
+    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>;
+    threads: import("../../../types").ThreadSummary[];
+    isThreadsLoading: boolean;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import type { MouseEvent as ReactMouseEvent } from "react";
+export declare function useFilePreview(options: {
+    allowFileOpen: boolean;
+    currentThreadId?: string | null;
+}): {
+    uploadingFiles: Record<number, boolean>;
+    handleFileClick: (e: ReactMouseEvent<HTMLAnchorElement>, fp: any, idx: number) => Promise<void>;
+    fileViewerOpen: boolean;
+    currentFileInfo: {
+        id: string;
+        name: string;
+        mimeType: string;
+    } | null;
+    closeFileViewer: () => void;
+};

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

@@ -0,0 +1,12 @@
+import type { ChatMessage, MessagePart } from "@/types";
+import type { ToolMeta } from "@/types";
+export interface ParsedMessageContent {
+    contentParts: MessagePart[];
+    textContent: string;
+    toolMeta: ToolMeta;
+    imageParts: MessagePart[];
+    fileParts: MessagePart[];
+    toolRaw: string;
+    isToolStreaming: boolean;
+}
+export declare function useParsedMessageContent(message: ChatMessage): ParsedMessageContent;

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

@@ -0,0 +1,44 @@
+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;
+        values?: Record<string, unknown>;
+    }) => 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/conversation/messages/components/MessageBubble.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactNode } from "react";
+import type { Role } from "@/types";
+export interface MessageBubbleProps {
+    role: Role;
+    header?: ReactNode;
+    content: ReactNode;
+    actions?: ReactNode;
+    status?: ReactNode;
+    isCompactLayout?: boolean;
+    /** UI-only override for background/border styling */
+    variant?: "default" | "minimal" | "accent";
+    customStyles?: {
+        container?: string;
+        bubble?: string;
+        content?: string;
+        header?: string;
+        actions?: string;
+    };
+}
+/**
+ * MessageBubble - The geometric template for all messages.
+ * This component defines the shared layout: where the header goes,
+ * how the content is padded, and where actions are positioned.
+ */
+export declare const MessageBubble: React.NamedExoticComponent<MessageBubbleProps>;

package/dist/features/conversation/messages/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useMessageContent";
+export * from "./useStreamingMarkdownBuffer";

package/dist/features/conversation/messages/hooks/useMessageContent.d.ts

@@ -0,0 +1,13 @@
+import type { ChatMessage, ImagePart, FilePart, ToolCall, MessagePart } from "@/types";
+export interface MessageContentResult {
+    textContent: string;
+    imageParts: ImagePart[];
+    fileParts: FilePart[];
+    toolCalls: ToolCall[];
+    contentParts: MessagePart[];
+}
+/**
+ * useMessageContent - Hook to extract content blocks from a ChatMessage.
+ * This is the "brain" for any message component.
+ */
+export declare function useMessageContent(message: ChatMessage | null | undefined): MessageContentResult;

package/dist/features/conversation/messages/hooks/useStreamingMarkdownBuffer.d.ts

@@ -0,0 +1,3 @@
+import type { MessagePart } from "@/types";
+export declare function useStreamingMarkdownBuffer(parts: MessagePart[], enabled: boolean, debounceMs: number): MessagePart[];
+export default useStreamingMarkdownBuffer;

package/dist/features/conversation/messages/hooks/useToolPayload.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "@/types";
+export type ToolPayloadEvent = Record<string, unknown>;
+export interface ToolPayloadBase {
+    value: unknown;
+    event: ToolPayloadEvent | null;
+}
+export interface ToolDictPayload extends ToolPayloadBase {
+    kind: "dict";
+    data: Record<string, unknown>;
+}
+export interface ToolGenericPayload extends ToolPayloadBase {
+    kind: "generic";
+}
+export type ToolPayloadResult = ToolDictPayload | ToolGenericPayload;
+export declare function useToolPayload(message: ChatMessage): ToolPayloadResult | null;

package/dist/features/conversation/messages/renderers/tooling/ToolContent.d.ts

@@ -0,0 +1,27 @@
+import type { ChatMessage, MessageArtifact, MessagePart, ToolArtifactRenderer, ToolArtifactRendererMap, ToolRenderer, ToolRendererMap, ToolConfig, ToolPayloadResult, ToolMeta, ToolViewMode } from "@/types";
+import { BuildToolConfigOptions } from "@/types";
+/**
+ * Context passed to tool renderers
+ */
+export interface ToolRendererContext {
+    message: ChatMessage;
+    toolMeta: ToolMeta;
+    toolPayload: ToolPayloadResult | null;
+    viewMode: ToolViewMode;
+    isStreaming: boolean;
+}
+/**
+ * Props for ToolContent component
+ */
+export interface ToolContentProps {
+    message: ChatMessage;
+    viewMode: ToolViewMode;
+    isStreaming?: boolean;
+    toolConfig?: ToolConfig;
+    expandable?: boolean;
+    artifactOverride?: MessageArtifact | null;
+    contentOverride?: MessagePart[] | null;
+}
+export type { ToolRenderer, ToolRendererMap, ToolConfig, ToolArtifactRenderer, ToolArtifactRendererMap, BuildToolConfigOptions };
+export declare function ToolContent({ message, viewMode, isStreaming, toolConfig, expandable, artifactOverride, contentOverride, }: ToolContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function createExpandableToolRenderer(renderer: ToolRenderer): ToolRenderer;

package/dist/features/conversation/messages/renderers/tooling/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/messages/utils/artifactUtils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Artifact Utilities
+ *
+ * Helper functions for working with artifacts, including metadata handling
+ * and streaming updates.
+ */
+import type { MessageArtifact, ChatMessage, ArtifactMetadata } from "@/types";
+/**
+ * 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 or associated tool call ID
+ */
+export declare function findMessageByArtifactId(messages: ChatMessage[], artifactId: string, toolCallId?: string): ChatMessage | null;
+import type { PlotData, ArtifactPreview } from "@/types";
+/**
+ * Normalize MIME type from format hints
+ */
+export declare function normalizeMimeType(formatHint?: string): string;
+/**
+ * Build label parts for artifact display
+ */
+export declare function buildLabelParts(extras?: {
+    plotId?: string;
+    artifactId?: string;
+}): string[];
+/**
+ * Create artifact preview object from source data
+ */
+export declare function createArtifactPreviewFromSource({ base64, url, formatHint, extras, }: {
+    base64?: string;
+    url?: string;
+    formatHint?: string;
+    extras?: {
+        plotId?: string;
+        artifactId?: string;
+    };
+}): ArtifactPreview | null;
+/**
+ * Create artifact preview object from Plot data
+ */
+export declare function createArtifactPreviewFromPlot(plot: PlotData): ArtifactPreview | null;

package/dist/features/conversation/messages/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "@/shared/core/utils/guards";
+export * from "@/shared/core/utils/parsers";
+export * from "@/shared/core/utils/metaUtils";
+export * from "./artifactUtils";
+export * from "./messageUtils";
+export * from "@/shared/core/utils/toolCallUtils";

package/dist/features/conversation/messages/utils/messageUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Message utility functions for parsing, sanitizing, and rendering message content
+ */
+/**
+ * Check if an object is file-like (has file properties)
+ */
+export declare function isFileLike(x: any): boolean;
+/**
+ * Sanitize content for display by removing file-like objects and large content
+ */
+export declare function sanitizeForDisplay(x: any): any;
+/**
+ * Pretty print content for display
+ */
+export declare function pretty(x: any): string;
+/**
+ * Intelligently format tool output - markdown if it looks like it, otherwise raw
+ */
+export declare function formatToolOutput(x: any): {
+    content: string;
+    isMarkdown: boolean;
+};
+export { parseJsonSafe, looksLikeMarkdown } from "@/shared/utils/jsonUtils";
+import type { ChatMessage, MessagePart } from "@/types";
+/**
+ * Stringify tool call parts for display/debugging
+ */
+export declare function stringifyTool(parts: MessagePart[]): string;
+/**
+ * Check if a message has actual text or image content (not just tool calls)
+ */
+export declare function hasContent(message: ChatMessage): boolean;

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

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

package/dist/features/persistence/checkpoints/hooks/useCheckpointIndex.d.ts

@@ -0,0 +1,2 @@
+import type { HydratedCheckpointSnapshot } from "@/types";
+export declare function useCheckpointIndex(checkpoints: HydratedCheckpointSnapshot[]): import("../utils/checkpointIndex").CheckpointIndex;

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

@@ -0,0 +1,33 @@
+/**
+ * Checkpoint metadata + timeline helpers used by checkpoint features.
+ * Re-export the shared checkpoint models as well.
+ */
+export type { HydratedCheckpointSnapshot, PendingInterrupt, PregelTask } from "@/types/domain/persistence";
+export type EditMeta = {
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+};
+export type CheckpointMeta = {
+    id: string;
+    userMessageId: string | null;
+    attemptCount?: number;
+    isLatestAttempt?: boolean;
+    attemptIndex?: number;
+    step: number | null;
+    source: string | null;
+    createdAt: string | null;
+    namespace: string | null;
+    parentId: string | null;
+    next?: string | null;
+    parentConfig?: Record<string, unknown> | null;
+};
+export type TimelineCheckpoint = {
+    id: string;
+    messageId: string | null;
+    step: number | null;
+    source: string | null;
+    createdAt: string | null;
+    next?: string | null;
+    parentConfig?: Record<string, unknown> | null;
+    label?: string | null;
+};

package/dist/features/persistence/checkpoints/utils/checkpointIndex.d.ts

@@ -0,0 +1,18 @@
+import type { HydratedCheckpointSnapshot } from "@/types";
+import type { CheckpointMeta, TimelineCheckpoint } from "../types";
+export interface CheckpointIndex {
+    checkpoints: HydratedCheckpointSnapshot[];
+    checkpointMetaByCheckpointId: Map<string, CheckpointMeta>;
+    timeline: TimelineCheckpoint[];
+    messagePreviews: Map<string, string>;
+    getLatest: () => CheckpointMeta | undefined;
+    getCheckpoint: (id: string) => CheckpointMeta | undefined;
+    getMessageAttempts: (userMessageId: string) => CheckpointMeta[];
+}
+export declare function buildCheckpointIndex(checkpoints: HydratedCheckpointSnapshot[]): CheckpointIndex;
+export declare function getMessageAttemptInfo(messageId: string | undefined, checkpointId: string | null | undefined, index: CheckpointIndex): {
+    attemptCount: number;
+    attemptIndex: number;
+    attempts: CheckpointMeta[];
+};
+export declare function getCheckpointForMessage(checkpointId: string | null | undefined, index: CheckpointIndex): CheckpointMeta | null;

package/dist/features/persistence/checkpoints/utils/editUtils.d.ts

@@ -0,0 +1,11 @@
+import type { TimelineCheckpoint } from "../types";
+type ParentCheckpointInfo = {
+    checkpointId: string;
+    checkpointNs: string | null;
+};
+/**
+ * Given the timeline checkpoints for a thread, find the parent checkpoint that the
+ * backend should branch from when editing the provided message id.
+ */
+export declare function findParentCheckpointForEdit(timeline: TimelineCheckpoint[], messageId: string): ParentCheckpointInfo;
+export {};

package/dist/features/persistence/checkpoints/utils/historyUtils.d.ts

@@ -0,0 +1,8 @@
+import type { HistoryPayload, HydratedCheckpointSnapshot, PendingInterrupt } from "@/types";
+export type HistoryHydrationResult = {
+    threadId: string;
+    latest: HydratedCheckpointSnapshot | null;
+    checkpoints: HydratedCheckpointSnapshot[];
+    interrupt: PendingInterrupt;
+};
+export declare function hydrateHistorySnapshots(history: HistoryPayload | null | undefined): HistoryHydrationResult;

package/dist/features/persistence/checkpoints/utils/messagePreviews.d.ts

@@ -0,0 +1,8 @@
+import type { HydratedCheckpointSnapshot, ChatMessage } from '@/types';
+export declare function getPreviewForMessage(message: ChatMessage): string;
+/**
+ * Builds a map of checkpoint ID -> preview text.
+ * Each checkpoint gets its own preview based on the latest user message in that checkpoint.
+ * This ensures all checkpoints display accurate previews even if they reference the same message ID.
+ */
+export declare function buildCheckpointPreviewMap(checkpoints: HydratedCheckpointSnapshot[]): Map<string, string>;