teodor-new-chat-ui 4.3.397 → 4.3.399

package/dist/features/checkpoint/components/TimelineColumn.d.ts

@@ -0,0 +1,12 @@
+import type { TimelineCheckpoint } from "../types";
+export interface TimelineColumnProps {
+    timelineEntries: TimelineCheckpoint[];
+    activeCheckpointId?: string | null;
+    onSelectCheckpoint?: (checkpointId: string | null) => Promise<void> | void;
+    messagePreviews?: Map<string, string>;
+    className?: string;
+    onHoverStart?: () => void;
+    onHoverEnd?: () => void;
+}
+export declare const TimelineColumn: ({ timelineEntries, activeCheckpointId, onSelectCheckpoint, messagePreviews, className, onHoverStart, onHoverEnd, }: TimelineColumnProps) => import("react/jsx-runtime").JSX.Element | null;
+export default TimelineColumn;

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

@@ -0,0 +1 @@
+export { default as TimelineColumn } from "./TimelineColumn";

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

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

package/dist/features/checkpoint/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/checkpoint/hooks/useMessageMetadata.d.ts

@@ -0,0 +1,18 @@
+/**
+ * useMessageMetadata Hook
+ *
+ * Thin hook wrapper around resolveMessageMetadata() that handles memoization.
+ *
+ * @param message - The message to resolve metadata for
+ * @param index - The pre-built checkpoint index (contains all lookup maps)
+ * @returns Memoized resolved metadata
+ */
+import type { ChatMessage, DefaultMessage } from "@/types";
+import type { CheckpointIndex } from "../utils/checkpointIndex";
+import { type ResolvedMessageMetadata } from "../utils/messageMetadataResolver";
+/**
+ * Hook to resolve and memoize metadata for a single message.
+ * Uses the pure resolver function and adds React memoization.
+ */
+export declare function useMessageMetadata(message: ChatMessage | DefaultMessage | undefined, index: CheckpointIndex): ResolvedMessageMetadata;
+export type { ResolvedMessageMetadata };

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

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./hooks";
+export * from "./utils";
+export * from "./components";

package/dist/features/checkpoint/types.d.ts

@@ -0,0 +1,34 @@
+export type EditMeta = {
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+};
+export type CheckpointMeta = {
+    id: string;
+    step: number | null;
+    source: string | null;
+    createdAt: string | null;
+    namespace: string | null;
+    parentId: string | null;
+};
+export type CheckpointMetaWithAttempts = CheckpointMeta & {
+    attemptIndex: number;
+    attemptCount: number;
+    isLatestAttempt: boolean;
+    baseUserMessageId: string | null;
+};
+export type CheckpointAttemptInfo = {
+    checkpointId: string;
+    attemptIndex: number;
+    attemptCount: number;
+    isLatestAttempt: boolean;
+};
+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/{lib → features/checkpoint/utils}/attemptDetection.d.ts

@@ -11,6 +11,7 @@
  * msg3 appears in multiple checkpoints = multiple attempts/versions
  */
 import type { HydratedCheckpointSnapshot } from "@/types/models";
+import type { CheckpointAttemptInfo } from "../types";
 export interface AttemptMetadata {
     attemptIndex: number;
     attemptCount: number;
@@ -23,10 +24,5 @@ export interface AttemptMetadata {
  */
 export declare function buildAttemptMaps(checkpoints: HydratedCheckpointSnapshot[]): {
     attemptMetaById: Map<string, AttemptMetadata>;
-    userMessageIdToAttempts: Map<string, Array<{
-        checkpointId: string;
-        attemptIndex: number;
-        attemptCount: number;
-        isLatestAttempt: boolean;
-    }>>;
+    userMessageIdToAttempts: Map<string, CheckpointAttemptInfo[]>;
 };

package/dist/features/checkpoint/utils/checkpointIndex.d.ts

@@ -0,0 +1,15 @@
+import type { HydratedCheckpointSnapshot } from "@/types";
+import type { CheckpointAttemptInfo, CheckpointMeta, CheckpointMetaWithAttempts, TimelineCheckpoint } from "../types";
+export interface CheckpointIndex {
+    checkpoints: HydratedCheckpointSnapshot[];
+    checkpointMetaById: Map<string, CheckpointMeta>;
+    checkpointIndexByKey: Map<string, CheckpointMeta[]>;
+    attemptMetaById: Map<string, CheckpointMetaWithAttempts>;
+    userMessageIdToAttempts: Map<string, CheckpointAttemptInfo[]>;
+    timeline: TimelineCheckpoint[];
+    messagePreviews: Map<string, string>;
+    getLatest: () => CheckpointMeta | undefined;
+    getCheckpoint: (id: string) => CheckpointMeta | undefined;
+    getAttempts: (userMessageId: string) => CheckpointAttemptInfo[];
+}
+export declare function buildCheckpointIndex(checkpoints: HydratedCheckpointSnapshot[]): CheckpointIndex;

package/dist/features/checkpoint/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./checkpointIndex";
+export * from "./attemptDetection";
+export * from "./historyUtils";
+export * from "./messageMetadataResolver";
+export * from "./messagePreviews";
+export * from "./schemaUtils";
+export * from "../types";

package/dist/features/checkpoint/utils/messageMetadataResolver.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Message Metadata Resolver
+ *
+ * Pure function that resolves checkpoint metadata for a single message.
+ * Extracted from the hook for:
+ * - Better testability (pure function)
+ * - Reusability outside React context
+ * - Clear separation of heuristics from memoization
+ */
+import type { ChatMessage, DefaultMessage } from "@/types";
+import type { CheckpointIndex } from "./checkpointIndex";
+import type { CheckpointMeta } from "../types";
+export interface ResolvedMessageMetadata {
+    checkpointCandidates: CheckpointMeta[];
+    defaultCheckpointId: string | null;
+    resolvedStep: number | null;
+    resolvedSource: string | null;
+}
+/**
+ * Resolves checkpoint metadata for a message given a checkpoint index.
+ *
+ * Handles:
+ * - Multi-source step/source fallback (additionalKwargs > responseMetadata > index)
+ * - Checkpoint candidate lookup by step:source key
+ * - Attempt filtering for edited/multi-version messages
+ * - Attempt metadata enrichment
+ *
+ * @param message - The message to resolve metadata for
+ * @param index - The pre-built checkpoint index (consolidates all lookup maps)
+ * @returns Resolved metadata including candidates and resolved step/source
+ */
+export declare function resolveMessageMetadata(message: ChatMessage | DefaultMessage | undefined, index: CheckpointIndex): ResolvedMessageMetadata;

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

@@ -1,5 +1,6 @@
 import type { ChatMessage } from '@/types';
 import type { HydratedCheckpointSnapshot } from '@/types/models';
+export declare function getPreviewForMessage(message: ChatMessage): string;
 /**
  * Legacy function: builds a map of message ID -> preview text.
  * This creates a single preview per message ID, with later occurrences overwriting earlier ones.

package/dist/{api/chat-api.d.ts → features/core/api/clients/chatClient.d.ts}

@@ -1,6 +1,5 @@
-import type { AgentDetail, AgentSchemaInfo, AgentSummary, HistoryPayload, SharedThreadSummary, StateSnapshot, ThreadInfo, ThreadShareResponse, ThreadSummary } from "@/types";
-import type { TokenListener } from "../types";
-import { getChatToken, onChatTokenChanged, setChatToken } from "./utils";
+import type { AgentDetail, AgentSchemaInfo, AgentSummary, HistoryPayload, SharedThreadSummary, StateSnapshot, ThreadInfo, ThreadShareResponse, ThreadSummary, TokenListener } from "@/types";
+import { getChatToken, onChatTokenChanged, setChatToken } from "../utils";
 export declare class ChatApi {
     get baseUrl(): string;
     updateConfig(config: {

package/dist/features/core/api/clients/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./chatClient";
+export * from "./fileClient";

package/dist/features/core/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./clients";
+export * from "./utils";

package/dist/features/core/api/utils/index.d.ts

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

package/dist/{config → features/core/constants}/env.d.ts

@@ -1,4 +1,4 @@
-import type { ApiConfig } from "@/types";
+import type { ApiConfig } from "@/features/core/types";
 /**
  * Get the default API configuration from runtime globals (if provided)
  */

package/dist/features/core/constants/index.d.ts

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

package/dist/{context → features/core/contexts}/ChatProviders.d.ts

@@ -5,8 +5,8 @@
  * ApiProvider (auth token & API client)
  * └─ ChatSessionProvider (threads, messages, and streaming state)
  */
-import type { ApiConfig } from '@/types';
-import type { ToolEndEvent } from '@/types/events';
+import type { ApiConfig } from '@/features/core/types';
+import type { ToolEndEvent } from '@/features/streaming';
 import { type ReactNode } from 'react';
 export interface ChatProvidersProps {
     children: ReactNode;
@@ -24,4 +24,3 @@ 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 './providers/ApiProvider';
 export { useStream, useThreads, useThreadState } from './providers/ChatSessionProvider';
-export type { ApiContextValue, SendOptions, StreamContextValue, ThreadsContextValue, ThreadStateContextValue } from './types';

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

@@ -0,0 +1,6 @@
+/**
+ * Public API entry point for shared contexts.
+ */
+export { ChatProviders, type ChatProvidersProps } from './ChatProviders';
+export { useApi } from './providers/ApiProvider';
+export { useThreadState, useStream, useThreads, useHasChatSession, } from './providers/ChatSessionProvider';

package/dist/{context → features/core/contexts}/providers/ApiProvider.d.ts

@@ -1,7 +1,7 @@
 /**
  * ApiProvider - Lowest level context providing API client and auth token
  */
-import type { ApiConfig, ApiContextValue } from '@/types';
+import type { ApiConfig, ApiContextValue } from '@/features/core/types';
 import { type ReactNode } from 'react';
 export interface ApiProviderProps {
     children: ReactNode;

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

@@ -0,0 +1 @@
+export { StreamingProvider as ChatSessionProvider, useStream, useThreads, useThreadState, useHasChatSession, } from "@/features/streaming/contexts";

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

@@ -0,0 +1,2 @@
+export { useApi } from "../contexts/providers/ApiProvider";
+export { useHasChatSession, useStream, useThreadState, useThreads, } from "../contexts/providers/ChatSessionProvider";

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

@@ -0,0 +1,6 @@
+export * from "./api";
+export * from "./contexts";
+export * from "./hooks";
+export * from "./types";
+export * from "./utils";
+export * from "./constants";

package/dist/{types → features/core/types}/context.d.ts

@@ -1,5 +1,5 @@
-import type { MessageStreamEvent, StreamCommand, StreamEvent, SystemStreamEvent, ThreadStreamEvent, ToolStreamEvent } from "./events";
-import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, ThreadSummary } from "./models";
+import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, ThreadSummary } from "@/types";
+import type { MessageStreamEvent, StreamCommand, StreamEvent, SystemStreamEvent, ThreadStreamEvent, ToolStreamEvent } from "@/features/streaming";
 export interface ApiConfig {
     baseUrl?: string;
     apiKey?: string;
@@ -22,7 +22,7 @@ export interface ApiContextValue {
     token: string | null;
     setToken: (token: string | null) => void;
     baseUrl: string;
-    api: import("@/api/chat-api").ChatApi;
+    api: import("@/features/core").ChatApi;
 }
 export interface ThreadsContextValue {
     threads: ThreadSummary[];

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

@@ -0,0 +1,7 @@
+/**
+ * Core Infrastructure Types
+ *
+ * Re-exports global types from @/types for convenience.
+ * Don't add feature-specific types here - keep them in their feature folders.
+ */
+export * from "./context";

package/dist/features/core/utils/index.d.ts

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

package/dist/{components → features/messaging/components}/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 '@/context/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,7 +21,6 @@ export interface SimpleChatProps {
     onError?: (error: string) => void;
 }
 export declare function SimpleChat({ apiConfig, className, onError }: SimpleChatProps): import("react/jsx-runtime").JSX.Element;
-export * from '@/context';
 export * from './ChatInterface';
 export * from './ThreadManager';
 export * from './MessageComponent';

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

@@ -2,7 +2,7 @@
  * Message Component - With truncatable tool messages and responsive design
  */
 import type { ChatMessage, DefaultMessage, PendingInterrupt } from "@/types";
-import type { CheckpointMeta, CheckpointMetaWithAttempts, EditMeta } from "@/hooks/checkpoints";
+import type { CheckpointMeta, EditMeta } from "@/features/checkpoint/types";
 export interface MessageComponentProps {
     message: ChatMessage | DefaultMessage;
     messageIndex: number;
@@ -36,7 +36,6 @@ export interface MessageComponentProps {
     onSelectCheckpoint?: (checkpointId: string | null, parentCheckpointId?: string | null, isLatest?: boolean) => Promise<void> | void;
     defaultCheckpointId?: string | null;
     messageParentCheckpointId?: string | null;
-    attemptMeta?: CheckpointMetaWithAttempts | null;
 }
 export declare const MessageComponent: import("react").NamedExoticComponent<MessageComponentProps>;
 export default MessageComponent;

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

@@ -1,5 +1,6 @@
 import type { ChatMessage, DefaultMessage, PendingInterrupt } from "@/types";
-import type { CheckpointMeta, CheckpointMetaWithAttempts, EditMeta, TimelineCheckpoint } from "@/hooks/checkpoints";
+import type { EditMeta, TimelineCheckpoint } from "@/features/checkpoint/types";
+import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
 import React from "react";
 export interface MessageListProps {
     messages: (ChatMessage | DefaultMessage)[];
@@ -34,19 +35,10 @@ export interface MessageListProps {
     onInterruptActionEnd?: () => void;
     showToolMessages?: boolean;
     showArtifactPreviews?: boolean;
-    checkpointMetaById?: Map<string, CheckpointMeta>;
-    checkpointIndexByKey?: Map<string, CheckpointMeta[]>;
-    attemptMetaById?: Map<string, CheckpointMetaWithAttempts>;
-    userMessageIdToAttempts?: Map<string, Array<{
-        checkpointId: string;
-        attemptIndex: number;
-        attemptCount: number;
-        isLatestAttempt: boolean;
-    }>>;
+    checkpointIndex?: CheckpointIndex;
     activeCheckpointId?: string | null;
     onSelectCheckpoint?: (checkpointId: string | null) => Promise<void> | void;
     timelineCheckpoints?: TimelineCheckpoint[];
-    messagePreviews?: Map<string, string>;
     /** If true, creates a synthetic thinking message when isStreaming=true and no assistant message exists */
     createSyntheticThinkingMessage?: boolean;
 }

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

@@ -1,5 +1,6 @@
 import type { ChatMessage, DefaultMessage, PendingInterrupt } from "@/types";
-import type { CheckpointMeta, CheckpointMetaWithAttempts, EditMeta } from "@/hooks/checkpoints";
+import type { EditMeta } from "@/features/checkpoint/types";
+import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
 import React from "react";
 export declare const getMessageDomKey: (message: ChatMessage | DefaultMessage | undefined, index: number) => string;
 export interface MessageRowProps {
@@ -20,15 +21,7 @@ export interface MessageRowProps {
     onInterruptActionEnd?: () => void;
     showToolMessages: boolean;
     showArtifactPreviews: boolean;
-    checkpointMetaById?: Map<string, CheckpointMeta>;
-    checkpointIndexByKey?: Map<string, CheckpointMeta[]>;
-    attemptMetaById?: Map<string, CheckpointMetaWithAttempts>;
-    userMessageIdToAttempts?: Map<string, Array<{
-        checkpointId: string;
-        attemptIndex: number;
-        attemptCount: number;
-        isLatestAttempt: boolean;
-    }>>;
+    checkpointIndex?: CheckpointIndex;
     activeCheckpointId?: string | null;
     onSelectCheckpoint?: (checkpointId: string | null) => Promise<void> | void;
 }

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

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

package/dist/{context/providers/ChatSessionProvider.d.ts → features/streaming/contexts/StreamingProvider.d.ts}

@@ -1,5 +1,5 @@
 /**
- * DEMO-SIMPLIFIED ChatSessionProvider
+ * DEMO-SIMPLIFIED StreamingProvider
  *
  * This is a reduced version optimized for demo/development with ~50% fewer lines.
  *
@@ -31,10 +31,11 @@
  *
  * RESULT: Much easier to debug, faster development, no stale cache issues
  */
-import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, SharedThreadSummary, StreamContextValue, ThreadSummary } from '@/types';
-import type { TimelineCheckpoint } from "@/hooks/checkpoints";
-import type { ThreadStateMetadata } from '@/types/context';
-import type { ToolEndEvent } from '@/types/events';
+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 ReactNode } from 'react';
 interface ThreadsContextValue {
     threads: ThreadSummary[];
@@ -66,6 +67,7 @@ interface ThreadStateContextValue {
         namespace: string | null;
     };
     checkpoints: HydratedCheckpointSnapshot[];
+    checkpointIndex: CheckpointIndex;
     timelineCheckpoints: TimelineCheckpoint[];
     metadata: ThreadStateMetadata | null;
     isLoading: boolean;
@@ -85,7 +87,7 @@ interface ThreadStateContextValue {
     respondToInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
     messagePreviews: Map<string, string>;
 }
-interface ChatSessionProviderProps {
+interface StreamingProviderProps {
     children: ReactNode;
     initialThreadId?: string | null;
     initialCheckpointId?: string | null;
@@ -97,9 +99,9 @@ interface ChatSessionProviderProps {
     onConnectionError?: (error: string) => void;
     onToolEnd?: (event: ToolEndEvent) => void;
 }
-export declare function ChatSessionProvider({ children, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, onError, onAuthError, onThreadChange, onConnectionError, onToolEnd, }: ChatSessionProviderProps): import("react/jsx-runtime").JSX.Element;
+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 ChatSessionProvider
+* Hook to check if the current component is within a StreamingProvider
  */
 export declare function useHasChatSession(): boolean;
 export declare function useThreads(): ThreadsContextValue;

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

@@ -0,0 +1,3 @@
+export { StreamingProvider } from "./StreamingProvider";
+export { useStream, useThreads, useThreadState, useHasChatSession } from "./StreamingProvider";
+export { useChatStreamingService } from "./services/use-streaming-service";

package/dist/{context/services/streaming → features/streaming/contexts/services}/use-streaming-service.d.ts

@@ -1,14 +1,5 @@
-import type { ChatRequest, HistoryPayload, StreamEvent } from '@/types';
-export type ThreadInfoEvent = Extract<StreamEvent, {
-    type: 'thread_info';
-}>;
-type HeartbeatEvent = Extract<StreamEvent, {
-    type: 'heartbeat';
-}>;
-export type StateHistoryEvent = HistoryPayload & {
-    type: 'state_history';
-    seq?: number;
-};
+import type { ChatRequest, HistoryPayload } from '@/types';
+import { type HeartbeatEvent, type StateHistoryEvent, type StreamEvent, type ThreadInfoEvent } from "@/features/streaming";
 export interface StreamClosedInfo {
     reason: 'complete' | 'aborted' | 'error';
     lastSeq: number;
@@ -55,7 +46,7 @@ interface StartStreamCallbacks {
 }
 /**
  * Thin integration layer that adapts the public `useStream` hook to the
- * coordination callbacks expected by `ChatSessionProvider`. Keeping this logic
+ * coordination callbacks expected by `StreamingProvider`. Keeping this logic
  * here means we continue to rely on the well-tested streaming hook for all SSE
  * behaviour while the provider focuses purely on state updates.
  */

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

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from "./contexts";
+export { useStream } from "./hooks/use-stream";

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

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

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

@@ -0,0 +1,109 @@
+import type { MessagePart, HistoryPayload } from "@/types";
+export type StreamCommand = {
+    kind: "resume";
+    value: unknown;
+} | {
+    kind: "goto";
+    node: string;
+    value?: unknown;
+};
+type ToolEventIdentity = {
+    id: string;
+    call_id?: string;
+} | {
+    call_id: string;
+    id?: string;
+};
+export type ToolStartEvent = {
+    type: "tool.start";
+    args: Record<string, unknown>;
+    name?: string;
+    tool?: string;
+    seq?: number;
+} & ToolEventIdentity;
+export type ToolEndEvent = {
+    type: "tool.end";
+    output: unknown;
+    artifact?: unknown;
+    error?: string;
+    name?: string;
+    tool?: string;
+    seq?: number;
+} & ToolEventIdentity;
+export type ToolProgressEvent = {
+    type: "tool.progress";
+    content?: string;
+    seq?: number;
+};
+export type ToolStreamEvent = ToolStartEvent | ToolEndEvent;
+export type MessageStreamEvent = {
+    type: "message.start";
+    role: "assistant";
+    id: string;
+    model?: string;
+} | {
+    type: "message.delta";
+    delta: MessagePart[];
+} | {
+    type: "message.end";
+} | ToolProgressEvent;
+export type ThreadStreamEvent = {
+    type: "thread_info";
+    threadId: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    lastMessage?: string | null;
+    created?: boolean | null;
+    ready?: boolean | null;
+    seq?: number | null;
+} | {
+    type: "checkpoint";
+    checkpointId: string;
+    checkpointNs?: string | null;
+};
+export type SystemStreamEvent = {
+    type: "error";
+    message: string;
+    error_type?: string;
+    code?: string;
+} | {
+    type: "interrupt";
+    id: string;
+    value: any;
+    seq: number;
+} | {
+    type: "heartbeat";
+    timestamp: number;
+    seq: number;
+} | {
+    type: "cancelled";
+    reason?: string;
+    seq?: number;
+} | ({
+    type: "state_history";
+    seq?: number;
+} & HistoryPayload);
+export type ThreadInfoEvent = Extract<ThreadStreamEvent, {
+    type: "thread_info";
+}>;
+export type HeartbeatEvent = Extract<SystemStreamEvent, {
+    type: "heartbeat";
+}>;
+export type StateHistoryEvent = Extract<SystemStreamEvent, {
+    type: "state_history";
+}>;
+/**
+ * Complete LangGraph streaming event union type.
+ * All SSE messages from backend must be one of these types.
+ */
+export type StreamEvent = MessageStreamEvent | ToolStreamEvent | ThreadStreamEvent | SystemStreamEvent;
+export declare function isStreamEvent(obj: any): obj is StreamEvent;
+export declare function isToolEvent(obj: any): obj is ToolStreamEvent;
+export declare function isToolStartEvent(obj: any): obj is ToolStartEvent;
+export declare function isToolEndEvent(obj: any): obj is ToolEndEvent;
+export declare function isMessageStreamEvent(obj: any): obj is MessageStreamEvent;
+export declare function isThreadStreamEvent(obj: any): obj is ThreadStreamEvent;
+export declare function isSystemStreamEvent(obj: any): obj is SystemStreamEvent;
+export {};

package/dist/{hooks → features/thread/hooks}/useThreadHistoryState.d.ts

@@ -1,8 +1,9 @@
-import type { ChatApi } from "@/api/chat-api";
-import type { StateHistoryEvent } from "@/context/services/streaming/use-streaming-service";
+import type { ChatApi } from "@/features/core";
+import type { StateHistoryEvent } from "@/features/streaming";
 import type { ChatMessage, HydratedCheckpointSnapshot } from "@/types";
-import type { TimelineCheckpoint } from "@/hooks/checkpoints";
+import type { TimelineCheckpoint } from "@/features/checkpoint/types";
 import type { PendingInterrupt } from "@/types/models";
+import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
 interface UseThreadHistoryStateOptions {
     api: ChatApi;
     seed: (messages: ChatMessage[], opts?: {
@@ -23,6 +24,7 @@ interface UseThreadHistoryStateOptions {
 interface ThreadHistoryResult {
     threadCheckpoints: HydratedCheckpointSnapshot[];
     threadTimeline: TimelineCheckpoint[];
+    checkpointIndex: CheckpointIndex;
     isLoadingThread: boolean;
     isHistoryLoading: boolean;
     isLoadingCheckpoint: boolean;

package/dist/{hooks → features/thread/hooks}/useThreadsState.d.ts

@@ -1,6 +1,6 @@
 import { type MutableRefObject } from 'react';
-import type { ChatApi } from '@/api/chat-api';
-import type { ThreadInfoEvent } from '@/context/services/streaming/use-streaming-service';
+import type { ChatApi } from "@/features/core";
+import type { ThreadInfoEvent } from '@/features/streaming';
 import type { SharedThreadSummary, ThreadSummary } from '@/types';
 interface ThreadActions {
     createThread: (title?: string) => Promise<string | null>;

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

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