@standardagents/react 0.10.1-next.bbd142a → 0.11.0-next.ab7e1ea

package/dist/index.d.ts

@@ -1,135 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-
-interface Message {
-    id: string;
-    role: "system" | "user" | "assistant" | "tool";
-    content: string | null;
-    name?: string | null;
-    tool_calls?: string | null;
-    tool_call_id?: string | null;
-    log_id?: string | null;
-    created_at: number;
-    request_sent_at?: number | null;
-    response_completed_at?: number | null;
-    status?: "pending" | "completed" | "failed";
-    silent?: boolean;
-    tool_status?: "success" | "error" | null;
-    reasoning_content?: string | null;
-    reasoning_details?: string | null;
-    parent_id?: string | null;
-    depth?: number;
-}
-interface WorkItem {
-    id: string;
-    type: "tool_call" | "tool_result";
-    name?: string;
-    content: string | null;
-    status?: "pending" | "success" | "error" | null;
-    tool_call_id?: string;
-}
-interface WorkMessage {
-    id: string;
-    type: "workblock";
-    content: string | null;
-    reasoning_content?: string | null;
-    workItems: WorkItem[];
-    status: "pending" | "completed" | "failed";
-    created_at: number;
-    depth?: number;
-}
-type ThreadMessage = Message | WorkMessage;
-interface AgentBuilderConfig {
-    endpoint: string;
-}
-interface UseThreadOptions {
-    preload?: boolean;
-    live?: boolean;
-    endpoint?: string;
-    stream?: boolean;
-    useWorkblocks?: boolean;
-    depth?: number;
-}
-interface GetMessagesOptions {
-    limit?: number;
-    offset?: number;
-    depth?: number;
-    includeSilent?: boolean;
-}
-interface MessageDataEvent {
-    type: "message_data";
-    message_id: string;
-    depth: number;
-    data: Message;
-}
-interface MessageChunkEvent {
-    type: "message_chunk";
-    message_id: string;
-    depth: number;
-    chunk: string;
-}
-interface ErrorEvent {
-    type: "error";
-    error: string;
-}
-/**
- * Custom thread event emitted via emitThreadEvent on the backend
- */
-interface ThreadEvent<T = unknown> {
-    type: "event";
-    eventType: string;
-    data: T;
-    timestamp: number;
-}
-type MessageStreamEvent = MessageDataEvent | MessageChunkEvent | ErrorEvent | ThreadEvent;
-interface LogDataEvent {
-    type: "log_data";
-    log_id: string;
-    data: any;
-}
-interface CustomEvent {
-    type: "custom";
-    customType: string;
-    value: any;
-    timestamp: number;
-}
-interface StoppedByUserEvent {
-    type: "stopped_by_user";
-    timestamp: number;
-}
-type LogStreamEvent = LogDataEvent | CustomEvent | StoppedByUserEvent;
-interface SendMessagePayload {
-    role: "user" | "assistant" | "system";
-    content: string;
-    silent?: boolean;
-}
-interface Thread {
-    id: string;
-    agent_id: string;
-    metadata?: Record<string, any>;
-    created_at: number;
-}
-interface MessageWebSocketCallbacks {
-    onMessage?: (event: MessageDataEvent) => void;
-    onChunk?: (event: MessageChunkEvent) => void;
-    onEvent?: (event: ThreadEvent) => void;
-    onError?: (event: ErrorEvent) => void;
-    onOpen?: () => void;
-    onClose?: () => void;
-}
-interface LogWebSocketCallbacks {
-    onLog?: (event: LogDataEvent) => void;
-    onCustom?: (event: CustomEvent) => void;
-    onStopped?: (event: StoppedByUserEvent) => void;
-    onOpen?: () => void;
-    onClose?: () => void;
-}
-interface ThreadProviderOptions {
-    /** Maximum message depth to fetch/stream */
-    depth?: number;
-    /** Whether to include silent messages */
-    includeSilent?: boolean;
-}
+import { AgentBuilderConfig, Message, ThreadMessage, ConnectionStatus as ConnectionStatus$1, SendMessagePayload, ThreadFile, PendingAttachment } from '@standardagents/client';
+export { AgentBuilderClient, AgentBuilderConfig, AttachmentPayload, AttachmentRef, CreateThreadPayload, CustomEvent, ErrorEvent, FileUploadManager, GetMessagesOptions, LogDataEvent, LogStreamEvent, LogWebSocketCallbacks, Message, MessageChunkEvent, MessageDataEvent, MessageStreamEvent, MessageWebSocketCallbacks, PendingAttachment, SendMessagePayload, StoppedByUserEvent, Thread, ThreadConnectionCallbacks, ThreadConnectionManager, ThreadConnectionOptions, ThreadEvent, ThreadFile, ThreadMessage, WorkItem, WorkMessage, generatePendingFileId, isImageMimeType, messagesToFiles, parseAttachments, readFileAsDataUrl, transformToWorkblocks } from '@standardagents/client';
 
 interface AgentBuilderProviderProps {
     config: AgentBuilderConfig;
@@ -148,6 +20,19 @@ interface AgentBuilderProviderProps {
  */
 declare function AgentBuilderProvider({ config, children }: AgentBuilderProviderProps): react_jsx_runtime.JSX.Element;
 
+interface ThreadProviderOptions {
+    /** Whether to preload messages on mount (default: true) */
+    preload?: boolean;
+    /** Whether to connect to live updates (default: true) */
+    live?: boolean;
+    /** Transform messages to workblocks (default: false) */
+    useWorkblocks?: boolean;
+    /** Maximum message depth to fetch/stream (default: 0) */
+    depth?: number;
+    /** Whether to include silent messages (default: false) */
+    includeSilent?: boolean;
+}
+
 /**
  * Event listener callback type
  */
@@ -155,25 +40,57 @@ type EventListener<T = unknown> = (data: T) => void;
 /**
  * WebSocket connection status
  */
-type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
+type ConnectionStatus = ConnectionStatus$1;
 /**
- * Thread context value
+ * Thread context value - the public interface returned by useThread()
  */
 interface ThreadContextValue {
     /** The thread ID */
     threadId: string;
     /** Current messages in the thread */
     messages: Message[];
-    /** Whether messages are currently loading */
+    /** Messages transformed to workblocks (if useWorkblocks is true) */
+    workblocks: ThreadMessage[];
+    /** Whether messages are currently loading (alias: isLoading) */
     loading: boolean;
+    /** Whether messages are currently loading (alias for loading) */
+    isLoading: boolean;
     /** Any error that occurred */
     error: Error | null;
-    /** WebSocket connection status */
+    /** WebSocket connection status (alias: status) */
     connectionStatus: ConnectionStatus;
-    /** Subscribe to a specific event type */
+    /** WebSocket connection status (alias for connectionStatus) */
+    status: ConnectionStatus;
+    /** Subscribe to a specific event type (alias: onEvent) */
     subscribeToEvent: <T = unknown>(eventType: string, listener: EventListener<T>) => () => void;
+    /** Subscribe to a specific event type (alias for subscribeToEvent) */
+    onEvent: <T = unknown>(eventType: string, listener: EventListener<T>) => () => void;
     /** Options passed to the provider */
     options: ThreadProviderOptions;
+    /** Send a message to the thread (auto-includes pending attachments) */
+    sendMessage: (payload: Omit<SendMessagePayload, 'attachments'>) => Promise<Message>;
+    /** Stop the current execution */
+    stopExecution: () => Promise<void>;
+    /** All files in the thread (pending uploads + committed from messages) */
+    files: ThreadFile[];
+    /** Add files and start uploading immediately to filesystem */
+    addFiles: (files: File[] | FileList) => void;
+    /** Remove a pending file (cannot remove committed files) */
+    removeFile: (id: string) => void;
+    /** Get the full URL for a file */
+    getFileUrl: (file: ThreadFile) => string;
+    /** Get the thumbnail URL for an image file */
+    getThumbnailUrl: (file: ThreadFile) => string;
+    /** Get preview URL - localPreviewUrl for pending images, thumbnail for committed */
+    getPreviewUrl: (file: ThreadFile) => string | null;
+    /** Pending attachments to be sent with next message */
+    attachments: PendingAttachment[];
+    /** Add attachment(s) to be sent with next message (no upload, stored locally) */
+    addAttachment: (files: File | File[] | FileList) => void;
+    /** Remove a pending attachment */
+    removeAttachment: (id: string) => void;
+    /** Clear all pending attachments */
+    clearAttachments: () => void;
 }
 interface ThreadProviderProps {
     /** The thread ID to connect to */
@@ -184,6 +101,8 @@ interface ThreadProviderProps {
     preload?: boolean;
     /** Whether to enable live updates via WebSocket (default: true) */
     live?: boolean;
+    /** Transform messages to workblocks (default: false) */
+    useWorkblocks?: boolean;
     /** Maximum message depth to fetch/stream (default: 0 for top-level only) */
     depth?: number;
     /** Whether to include silent messages (default: false) */
@@ -207,8 +126,10 @@ interface ThreadProviderProps {
  * </AgentBuilderProvider>
  * ```
  */
-declare function ThreadProvider({ threadId, options, preload, live, depth, includeSilent, endpoint: endpointOverride, children, }: ThreadProviderProps): react_jsx_runtime.JSX.Element;
+declare function ThreadProvider({ threadId, options, preload, live, useWorkblocks, depth, includeSilent, endpoint: endpointOverride, children, }: ThreadProviderProps): react_jsx_runtime.JSX.Element;
 /**
+ * @deprecated Use `useThread()` instead.
+ *
  * Hook to access the thread context.
  * Must be used within a ThreadProvider.
  *
@@ -222,23 +143,24 @@ declare function useThreadContext(): ThreadContextValue;
 declare function useThreadId(): string;
 
 /**
- * Hook to get messages from a thread.
+ * Hook to access the thread context.
  *
- * Must be used within a ThreadProvider. The thread ID and WebSocket connection
- * are managed by the ThreadProvider, so this hook simply returns the messages.
+ * Must be used within a ThreadProvider. Returns the full thread context
+ * including messages, actions, and file management.
  *
- * @param options - Configuration options
- * @returns Array of messages (raw or transformed to workblocks)
+ * @returns The thread context value
  *
  * @example
  * ```tsx
  * function ChatMessages() {
- *   // Basic usage - returns messages from context
- *   const messages = useThread()
+ *   const { messages, sendMessage, files } = useThread()
  *
  *   return (
  *     <div>
  *       {messages.map(msg => <Message key={msg.id} message={msg} />)}
+ *       <button onClick={() => sendMessage({ role: 'user', content: 'Hello!' })}>
+ *         Send
+ *       </button>
  *     </div>
  *   )
  * }
@@ -248,14 +170,8 @@ declare function useThreadId(): string;
  *   <ChatMessages />
  * </ThreadProvider>
  * ```
- *
- * @example
- * ```tsx
- * // Disable workblocks transformation
- * const messages = useThread({ useWorkblocks: false })
- * ```
  */
-declare function useThread(options?: UseThreadOptions): ThreadMessage[];
+declare function useThread(): ThreadContextValue;
 
 /**
  * Hook to listen for custom events emitted from a thread via the stream WebSocket.
@@ -339,6 +255,8 @@ declare function onThreadEvent<T = unknown>(type: string, callback: (data: T) =>
 declare function useThreadEvent<T = unknown>(type: string): T | null;
 
 /**
+ * @deprecated Use `const { sendMessage } = useThread()` instead.
+ *
  * Hook that returns a function to send messages to the current thread.
  * Must be used within a ThreadProvider.
  *
@@ -351,23 +269,20 @@ declare function useThreadEvent<T = unknown>(type: string): T | null;
  *
  * @example
  * ```tsx
- * function ChatInput() {
- *   const sendMessage = useSendMessage()
- *
- *   const handleSubmit = async (content: string) => {
- *     await sendMessage({
- *       role: 'user',
- *       content,
- *     })
- *   }
+ * // NEW - Recommended
+ * const { sendMessage } = useThread()
+ * await sendMessage({ role: 'user', content: 'Hello!' })
  *
- *   return <input onSubmit={handleSubmit} />
- * }
+ * // OLD - Deprecated
+ * const sendMessage = useSendMessage()
+ * await sendMessage({ role: 'user', content: 'Hello!' })
  * ```
  */
 declare function useSendMessage(): (payload: SendMessagePayload) => Promise<Message>;
 
 /**
+ * @deprecated Use `const { stopExecution } = useThread()` instead.
+ *
  * Hook that returns a function to stop the current thread's execution.
  * Must be used within a ThreadProvider.
  *
@@ -380,15 +295,13 @@ declare function useSendMessage(): (payload: SendMessagePayload) => Promise<Mess
  *
  * @example
  * ```tsx
- * function StopButton() {
- *   const stopThread = useStopThread()
+ * // NEW - Recommended
+ * const { stopExecution } = useThread()
+ * await stopExecution()
  *
- *   return (
- *     <button onClick={() => stopThread()}>
- *       Stop
- *     </button>
- *   )
- * }
+ * // OLD - Deprecated
+ * const stopThread = useStopThread()
+ * await stopThread()
  * ```
  */
 declare function useStopThread(): () => Promise<void>;
@@ -460,4 +373,4 @@ interface StopThreadOptions {
  */
 declare function stopThread(id: string, options?: StopThreadOptions): Promise<void>;
 
-export { type AgentBuilderConfig, AgentBuilderProvider, type ConnectionStatus, type CustomEvent, type ErrorEvent, type GetMessagesOptions, type LogDataEvent, type LogStreamEvent, type LogWebSocketCallbacks, type Message, type MessageChunkEvent, type MessageDataEvent, type MessageStreamEvent, type MessageWebSocketCallbacks, type SendMessagePayload, type StoppedByUserEvent, type Thread, type ThreadEvent, type ThreadMessage, ThreadProvider, type ThreadProviderOptions, type UseThreadOptions, type WorkItem, type WorkMessage, onThreadEvent, sendMessage, stopThread, useSendMessage, useStopThread, useThread, useThreadContext, useThreadEvent, useThreadId };
+export { AgentBuilderProvider, type ConnectionStatus, type ThreadContextValue, ThreadProvider, type ThreadProviderOptions, onThreadEvent, sendMessage, stopThread, useSendMessage, useStopThread, useThread, useThreadContext, useThreadEvent, useThreadId };