@agents24/chat-react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,351 @@
+import * as react from 'react';
+import { RefObject, ReactNode, UIEvent } from 'react';
+
+type ChatRunStatus = "queued" | "running" | "completed" | "cancelled" | "failed" | string;
+type ChatContextWindow = {
+    stage?: string;
+    label?: string;
+    usedTokens?: number;
+    maxTokens?: number;
+    [key: string]: unknown;
+};
+type ChatCitation = {
+    title: string;
+    url: string;
+    description: string;
+    sourceRef?: string;
+    ref?: string;
+    firstRef?: string;
+    totalSegments?: number;
+    rangeRef?: string;
+};
+type ChatAttachment = {
+    url?: string;
+    filename?: string;
+    mediaType?: string;
+    contentType?: string;
+    [key: string]: unknown;
+};
+type ChatReasoningStep = {
+    label: string;
+    status: "active" | "complete" | "pending";
+    icon?: unknown;
+    description?: string;
+    citations?: ChatCitation[];
+    query?: string;
+    sources?: Array<Record<string, unknown>>;
+};
+type ChatToolStatus = "running" | "done" | "error";
+type ChatToolActionKey = "search" | "navigate" | "resolve" | "read" | "context" | "links" | "work";
+type ChatTextBlock = {
+    id: string;
+    kind: "text";
+    content: string;
+};
+type ChatToolBlock = {
+    id: string;
+    kind: "tool";
+    title: string;
+    actionLabel: string;
+    actionKey: ChatToolActionKey;
+    status: ChatToolStatus;
+    detail?: string;
+};
+type ChatToolGroupBlock = {
+    id: string;
+    kind: "tool_group";
+    title: string;
+    status: ChatToolStatus;
+    tools: ChatToolBlock[];
+};
+type ChatMessageBlock = ChatTextBlock | ChatToolBlock | ChatToolGroupBlock;
+type ChatMessage = {
+    id: string;
+    role: "user" | "assistant";
+    runId?: string | null;
+    content: string;
+    createdAt: Date;
+    isFinal?: boolean;
+    blocks?: ChatMessageBlock[];
+    attachments?: ChatAttachment[];
+    citations?: ChatCitation[];
+    reasoningSteps?: ChatReasoningStep[];
+    thinkingDurationMs?: number;
+    liked?: boolean;
+    disliked?: boolean;
+    messageIndex?: number;
+    isVoice?: boolean;
+};
+type ChatRuntimeEvent = {
+    version?: string;
+    seq?: number;
+    ts?: string;
+    event: string;
+    run_id?: string;
+    stage?: string;
+    payload?: Record<string, unknown>;
+    diagnostics?: Array<Record<string, unknown>>;
+};
+type ChatActiveRun = {
+    run_id?: string | null;
+    status?: string | null;
+    started_at?: string | null;
+    created_at?: string | null;
+};
+type ChatThreadSummary = {
+    id: string;
+    title?: string | null;
+    status?: string | null;
+    surface?: string | null;
+    agent_id?: string | null;
+    last_run_id?: string | null;
+    last_run_status?: string | null;
+    active_run?: ChatActiveRun | null;
+    activeRun?: ChatActiveRun | null;
+    updated_at?: string | null;
+    last_activity_at?: string | null;
+    created_at?: string | null;
+    messages?: ChatMessage[];
+    isHydrated?: boolean;
+    hasOlderTurns?: boolean;
+    nextBeforeTurnIndex?: number | null;
+    lastRunId?: string | null;
+    lastRunStatus?: string | null;
+    lastEventSeq?: number | null;
+    isRunning?: boolean;
+    [key: string]: unknown;
+};
+type ChatThreadTurn = {
+    id?: string;
+    run_id?: string;
+    turn_index?: number;
+    status?: string | null;
+    user_input_text?: string | null;
+    assistant_output_text?: string | null;
+    final_output?: unknown;
+    response_blocks?: Array<Record<string, unknown>>;
+    run_events?: ChatRuntimeEvent[];
+    context_window?: unknown;
+    attachments?: Array<Record<string, unknown>>;
+    created_at?: string | null;
+    completed_at?: string | null;
+};
+type ChatThreadDetail = ChatThreadSummary & {
+    turns?: ChatThreadTurn[];
+    context_window?: unknown;
+    paging?: {
+        has_more?: boolean;
+        next_before_turn_index?: number | null;
+    };
+};
+type ChatTransport = {
+    listThreads: (input?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        items: ChatThreadSummary[];
+        total?: number;
+    }>;
+    getThread: (input: {
+        threadId: string;
+        limit?: number;
+        beforeTurnIndex?: number | null;
+        signal?: AbortSignal;
+    }) => Promise<ChatThreadDetail>;
+    streamMessage: (input: {
+        text: string;
+        threadId?: string | null;
+        files?: ChatAttachment[];
+        signal?: AbortSignal;
+    }, onEvent: (event: ChatRuntimeEvent) => void | Promise<void>) => Promise<ChatStreamResult>;
+    attachRun: (input: {
+        runId: string;
+        signal?: AbortSignal;
+    }, onEvent: (event: ChatRuntimeEvent) => void | Promise<void>) => Promise<ChatStreamResult>;
+    cancelRun: (input: {
+        runId: string;
+        assistantOutputText?: string;
+    }) => Promise<{
+        run_id?: string;
+        status?: string;
+    }>;
+    deleteThread?: (input: {
+        threadId: string;
+    }) => Promise<{
+        deleted?: boolean;
+    }>;
+    uploadAttachment?: (input: {
+        file: File;
+        signal?: AbortSignal;
+    }) => Promise<ChatAttachment>;
+};
+type ChatStreamResult = {
+    threadId?: string | null;
+    runId?: string | null;
+};
+type StoredChatThread = ChatThreadSummary & {
+    messages: ChatMessage[];
+    isHydrated?: boolean;
+    hasOlderTurns?: boolean;
+    nextBeforeTurnIndex?: number | null;
+};
+type ChatStorageAdapter = {
+    listThreads: () => StoredChatThread[];
+    setThreads: (threads: StoredChatThread[]) => void;
+    getThread: (threadId: string) => StoredChatThread | undefined;
+    upsertThread: (thread: StoredChatThread) => void;
+    deleteThread?: (threadId: string) => void;
+    getActiveThreadId?: () => string | null;
+    setActiveThreadId?: (threadId: string | null) => void;
+};
+type ChatController = {
+    messages: ChatMessage[];
+    streamingContent: string;
+    streamingMessageId: string | null;
+    contextStatus: ChatContextWindow | null;
+    currentReasoning: ChatReasoningStep[];
+    isLoading: boolean;
+    isLoadingHistory: boolean;
+    isLoadingOlder: boolean;
+    hasOlderTurns: boolean;
+    liked: Record<string, boolean>;
+    disliked: Record<string, boolean>;
+    copiedMessageId: string | null;
+    lastThinkingDurationMs: number | null;
+    activeRunId: string | null;
+    handleSubmit: (message: {
+        text: string;
+        files?: ChatAttachment[];
+    }) => Promise<void>;
+    handleStop: () => void;
+    handleCopy: (content: string, messageId: string) => void;
+    handleLike: (msg: ChatMessage) => Promise<void>;
+    handleDislike: (msg: ChatMessage) => Promise<void>;
+    handleRetry: (msg: ChatMessage) => Promise<void>;
+    handleSourceClick: (citations: ChatMessage["citations"]) => void;
+    upsertLiveVoiceMessage: (input: {
+        role: "user" | "assistant";
+        content: string;
+        isFinal?: boolean;
+        citations?: ChatCitation[];
+        reasoningSteps?: ChatReasoningStep[];
+    }) => void;
+    loadOlderTurns: () => Promise<void>;
+    refresh: () => Promise<void>;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+};
+
+type UseAgents24ChatControllerOptions = {
+    transport: ChatTransport;
+    storage: ChatStorageAdapter;
+    activeThreadId?: string | null;
+    pageSize?: number;
+    storageKey?: unknown;
+    createId?: () => string;
+    onActiveThreadIdChange?: (threadId: string | null) => void;
+    onSourceClick?: (citations: ChatMessage["citations"]) => void;
+    onStreamErrorMessage?: (error: unknown) => string;
+};
+declare function useAgents24ChatController({ transport, storage, activeThreadId: controlledActiveThreadId, pageSize, storageKey, createId, onActiveThreadIdChange, onSourceClick, onStreamErrorMessage, }: UseAgents24ChatControllerOptions): ChatController;
+
+declare const DEFAULT_THREAD_PAGE_SIZE = 5;
+declare const isRunningThreadStatus: (status?: string | null) => boolean;
+declare const createChatId: () => string;
+declare const titleFromMessage: (text: string, files?: Array<{
+    filename?: string;
+}>) => string;
+declare const threadActivityDate: (thread: ChatThreadSummary) => string;
+declare const assistantTextFromBlocks: (blocks?: Array<Record<string, unknown>>) => string;
+declare const textFromFinalOutput: (value: unknown) => string;
+declare const renderBlocksFromResponseBlocks: (blocks?: Array<Record<string, unknown>>, fallbackText?: string) => ChatMessageBlock[];
+declare const mergeReasoningSteps: (steps?: ChatReasoningStep[], options?: {
+    finalize?: boolean;
+}) => ChatReasoningStep[];
+declare const reasoningStepsFromBlocks: (blocks?: Array<Record<string, unknown>>) => ChatReasoningStep[];
+declare const threadDetailToMessages: (thread: ChatThreadDetail) => ChatMessage[];
+declare const threadPaging: (thread: ChatThreadDetail) => {
+    hasOlderTurns: boolean;
+    nextBeforeTurnIndex: number | null;
+};
+declare const latestContextWindowFromThread: (thread: ChatThreadDetail) => ChatContextWindow | null;
+declare const activeRunIdFromThread: (thread?: Partial<ChatThreadSummary> | null) => string | null;
+declare const hasUnfinishedAssistantMessage: (messages?: ChatMessage[]) => boolean;
+declare const hasStaleUnfinishedAssistantCache: (thread?: (Partial<ChatThreadSummary> & {
+    messages?: ChatMessage[];
+}) | null) => boolean;
+declare const activeRunIdFromThreadDetail: (thread?: ChatThreadDetail | null) => string | null;
+
+declare const parseSseBlock: (block: string) => ChatRuntimeEvent | null;
+declare const consumeSseResponse: (response: Response, onEvent: (event: ChatRuntimeEvent) => void | Promise<void>) => Promise<ChatStreamResult>;
+
+type MaybePromise<T> = T | Promise<T>;
+type FetchChatTransportRoutes = {
+    listThreads: () => string;
+    getThread: (input: {
+        threadId: string;
+        limit?: number;
+        beforeTurnIndex?: number | null;
+    }) => string;
+    streamMessage: () => string;
+    attachRun: (input: {
+        runId: string;
+    }) => string;
+    cancelRun: (input: {
+        runId: string;
+    }) => string;
+    deleteThread?: (input: {
+        threadId: string;
+    }) => string;
+};
+type FetchChatTransportOptions = {
+    routes: FetchChatTransportRoutes;
+    fetchImpl?: typeof fetch;
+    headers?: () => MaybePromise<HeadersInit>;
+    streamBody?: (input: {
+        text: string;
+        threadId?: string | null;
+        files?: ChatAttachment[];
+    }) => unknown;
+};
+declare const createFetchChatTransport: ({ routes, fetchImpl, headers, streamBody, }: FetchChatTransportOptions) => ChatTransport;
+
+declare const isScrollable: (element: Pick<HTMLDivElement, "scrollHeight" | "clientHeight">) => boolean;
+declare const isAtTimelineLatestEdge: (element: Pick<HTMLDivElement, "scrollHeight" | "clientHeight" | "scrollTop">, isTopOrigin: boolean) => boolean;
+declare const shouldPrefetchOlder: (element: Pick<HTMLDivElement, "scrollHeight" | "clientHeight" | "scrollTop">) => boolean;
+declare const getLatestScrollTop: (element: Pick<HTMLDivElement, "scrollHeight" | "clientHeight">, isTopOrigin: boolean) => number;
+type UseLatestThreadViewportOptions = {
+    itemCount: number;
+    hasOlder: boolean;
+    isLoadingOlder: boolean;
+    onLoadOlder: () => Promise<void> | void;
+    activeStreamKey?: string | null;
+    shouldAutoFollow?: boolean;
+    topOriginMaxItems?: number;
+};
+type LatestThreadViewportState = {
+    scrollContainerRef: RefObject<HTMLDivElement | null>;
+    isAtLatest: boolean;
+    isTopOrigin: boolean;
+    shouldShowLatestButton: boolean;
+    handleScroll: (event: UIEvent<HTMLDivElement>) => void;
+    scrollToLatest: () => void;
+    preserveIntrinsicResize: () => void;
+};
+declare function useLatestThreadViewport({ itemCount, hasOlder, isLoadingOlder, onLoadOlder, activeStreamKey, shouldAutoFollow, topOriginMaxItems, }: UseLatestThreadViewportOptions): LatestThreadViewportState;
+type LatestThreadViewportRenderContext = {
+    preserveIntrinsicResize: () => void;
+    isTopOrigin: boolean;
+};
+type LatestThreadViewportProps<T> = {
+    items: T[];
+    hasOlder: boolean;
+    isLoadingOlder: boolean;
+    onLoadOlder: () => Promise<void> | void;
+    activeStreamKey?: string | null;
+    className?: string;
+    latestSpacer?: ReactNode;
+    trailingSpacer?: ReactNode;
+    renderItem: (item: T, context: LatestThreadViewportRenderContext) => ReactNode;
+};
+declare function LatestThreadViewport<T>({ items, hasOlder, isLoadingOlder, onLoadOlder, activeStreamKey, className, latestSpacer, trailingSpacer, renderItem, }: LatestThreadViewportProps<T>): react.JSX.Element;
+
+export { type ChatActiveRun, type ChatAttachment, type ChatCitation, type ChatContextWindow, type ChatController, type ChatMessage, type ChatMessageBlock, type ChatReasoningStep, type ChatRunStatus, type ChatRuntimeEvent, type ChatStorageAdapter, type ChatStreamResult, type ChatTextBlock, type ChatThreadDetail, type ChatThreadSummary, type ChatThreadTurn, type ChatToolActionKey, type ChatToolBlock, type ChatToolGroupBlock, type ChatToolStatus, type ChatTransport, DEFAULT_THREAD_PAGE_SIZE, type FetchChatTransportOptions, type FetchChatTransportRoutes, LatestThreadViewport, type LatestThreadViewportProps, type LatestThreadViewportRenderContext, type LatestThreadViewportState, type StoredChatThread, type UseAgents24ChatControllerOptions, type UseLatestThreadViewportOptions, activeRunIdFromThread, activeRunIdFromThreadDetail, assistantTextFromBlocks, consumeSseResponse, createChatId, createFetchChatTransport, getLatestScrollTop, hasStaleUnfinishedAssistantCache, hasUnfinishedAssistantMessage, isAtTimelineLatestEdge, isRunningThreadStatus, isScrollable, latestContextWindowFromThread, mergeReasoningSteps, parseSseBlock, reasoningStepsFromBlocks, renderBlocksFromResponseBlocks, shouldPrefetchOlder, textFromFinalOutput, threadActivityDate, threadDetailToMessages, threadPaging, titleFromMessage, useAgents24ChatController, useLatestThreadViewport };