@teodorruskvi/chat-core 0.1.2

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

@@ -0,0 +1,6 @@
+type PlainObject = Record<string, unknown>;
+export declare function toPlainObject(value: unknown): PlainObject | undefined;
+export declare function readString(source: PlainObject | undefined, keys: string[]): string | undefined;
+export declare function readNumber(source: PlainObject | undefined, keys: string[]): number | null;
+export declare function extractConfigFields(source: unknown): PlainObject | undefined;
+export {};

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

@@ -0,0 +1,19 @@
+import type { StreamContextValue } from '@/types/core';
+import type { ToolEndEvent, StreamEvent, StreamFinishInfo } from "@/types/domain/streaming";
+import { type ReactNode } from 'react';
+interface StreamingProviderProps {
+    children: ReactNode;
+    onError?: (error: string) => void;
+    onAuthError?: (error: string) => void;
+    onConnectionError?: (error: string) => void;
+    onToolEnd?: (event: ToolEndEvent) => void;
+    onUpdateEvent?: (event: StreamEvent) => void;
+    onCustomEvent?: (event: StreamEvent) => void;
+    onMetadataEvent?: (event: StreamEvent) => void;
+    onFinish?: (info: StreamFinishInfo) => void;
+    onStreamingChange?: (isStreaming: boolean) => void;
+}
+export declare function StreamingProvider({ children, onError, onAuthError, onConnectionError, onToolEnd, onUpdateEvent, onCustomEvent, onMetadataEvent, onFinish, onStreamingChange, }: StreamingProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useStream(): StreamContextValue;
+export declare function useHasChatSession(): boolean;
+export {};

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

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

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

@@ -0,0 +1,76 @@
+import type { ChatMessage, ProjectInfo, ThreadSummary, PendingInterrupt, HydratedCheckpointSnapshot } from "@/types";
+import type { TimelineCheckpoint } from "@/features/persistence/checkpoints/types";
+import type { CheckpointIndex } from "@/features/persistence/checkpoints/utils/checkpointIndex";
+import type { StateHistoryEvent } from "@/types/domain/streaming";
+import type { MutableRefObject } from "react";
+import type { ThreadInfoEvent } from "@/types/domain/streaming";
+export interface ThreadsContextValue {
+    threads: ThreadSummary[];
+    currentThreadId: string | null;
+    setCurrentThreadId: (id: string | null) => void;
+    currentThreadIdRef: MutableRefObject<string | null>;
+    isLoading: boolean;
+    error: string | null;
+    sharedThreads: ThreadSummary[];
+    isLoadingSharedThreads: boolean;
+    actions: {
+        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>;
+    };
+    shareInFlight: boolean;
+    shareStatus: string | null;
+    clearShareStatus: () => void;
+    addThreadFromEvent: (threadInfo: ThreadInfoEvent) => void;
+}
+export interface ThreadStateContextValue {
+    threadId: string | null;
+    messages: ChatMessage[];
+    interrupt: PendingInterrupt;
+    checkpoint: {
+        id: string | null;
+        namespace: string | null;
+    };
+    checkpoints: HydratedCheckpointSnapshot[];
+    checkpointIndex: CheckpointIndex;
+    timelineCheckpoints: TimelineCheckpoint[];
+    metadata: {
+        assemblingMessageId: string | null;
+    };
+    values: Record<string, unknown>;
+    isLoading: boolean;
+    isLoadingCheckpoint: boolean;
+    error: string | null;
+    loadOlder: () => Promise<void>;
+    seedFromSnapshot: (snapshot: {
+        messages: ChatMessage[];
+        checkpointId?: string | null;
+        checkpointNs?: string | null;
+        interrupt?: PendingInterrupt;
+    }) => void;
+    clearState: () => Promise<void> | 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 | null, checkpointNs?: string | null) => Promise<void>;
+    clearThread: () => Promise<void> | void;
+    respondToInterrupt: (approved: boolean, value?: unknown, options?: any) => Promise<void>;
+    messagePreviews: Map<string, string>;
+    handleStateHistoryEvent: (payload: StateHistoryEvent) => void;
+    markSkipNextLoad: (threadId: string) => void;
+    markStreamPendingThread: (threadId: string) => void;
+    resetHistoryState: () => void;
+    pushUser: (content: string | ChatMessage, options?: {
+        editingMessageId?: string | null;
+    }) => ChatMessage;
+    onEvent: (ev: any) => void;
+    /** Global collection of artifacts discovered in the message history */
+    artifacts: import("@/types").MessageArtifact[];
+}

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

@@ -0,0 +1,50 @@
+import type { 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

@@ -0,0 +1,2 @@
+import type { UseChatStreamOptions, UseStreamApi } from "@/types/domain/streaming";
+export declare function useStream(hookOptions?: UseChatStreamOptions): UseStreamApi;

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

@@ -0,0 +1,5 @@
+export * from "./contexts";
+export { useStream, useStream as useStreamingHook } from "./hooks/use-stream";
+export type { UseStreamApi, UseChatStreamOptions, ActiveRunContext, } from "./hooks/types";
+export * from "./utils";
+export type { ToolEndEvent, ThreadInfoEvent, StateHistoryEvent } from "@/types/domain/streaming";

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

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

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

@@ -0,0 +1,14 @@
+import type { ToolEndEvent } from "@/types";
+/**
+ * Extracts a task ID from a tool end event payload.
+ * Supports both snake_case (task_id) and camelCase (taskId) keys on artifact or content payloads.
+ */
+export declare function extractTaskIdFromToolEnd(event: ToolEndEvent): string | null;
+/**
+ * Builds an onToolEnd handler that syncs task context and delegates to an optional user handler.
+ */
+export declare function createTaskSyncToolEndHandler(params: {
+    setCurrentTaskId: (taskId: string) => void;
+    getCurrentTaskId?: () => string | null;
+    onToolEnd?: (event: ToolEndEvent) => void;
+}): (event: ToolEndEvent) => void;

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

@@ -0,0 +1 @@
+export { ThreadsProvider, useThreads, ThreadStateProvider, useThreadState, useThreadStateUpdater, } from "@/features/conversation/contexts";

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

@@ -0,0 +1 @@
+export { useMessagesReducer, messagesReducer, initialMessagesState } from "@/features/conversation/contexts/reducers/MessageReducer";

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

@@ -0,0 +1 @@
+export { useThreadHistoryState } from "@/features/conversation/hooks/useThreadHistoryState";

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

@@ -0,0 +1 @@
+export { useThreadsState } from "@/features/conversation/hooks/useThreadsState";