@standardagents/react 0.10.1-dev.b8746e9 → 0.10.1-next.bbd142a

package/dist/index.d.ts

@@ -1,7 +1,135 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { AgentBuilderConfig, Message, ThreadMessage, ConnectionStatus as ConnectionStatus$1, SendMessagePayload, ThreadFile } from '@standardagents/client';
-export { AgentBuilderClient, AgentBuilderConfig, AttachmentRef, CreateThreadPayload, CustomEvent, ErrorEvent, FileUploadManager, GetMessagesOptions, LogDataEvent, LogStreamEvent, LogWebSocketCallbacks, Message, MessageChunkEvent, MessageDataEvent, MessageStreamEvent, MessageWebSocketCallbacks, SendMessagePayload, StoppedByUserEvent, Thread, ThreadConnectionCallbacks, ThreadConnectionManager, ThreadConnectionOptions, ThreadEvent, ThreadFile, ThreadMessage, WorkItem, WorkMessage, generatePendingFileId, isImageMimeType, messagesToFiles, parseAttachments, readFileAsDataUrl, transformToWorkblocks } from '@standardagents/client';
+
+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;
+}
 
 interface AgentBuilderProviderProps {
     config: AgentBuilderConfig;
@@ -20,19 +148,6 @@ 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
  */
@@ -40,49 +155,25 @@ type EventListener<T = unknown> = (data: T) => void;
 /**
  * WebSocket connection status
  */
-type ConnectionStatus = ConnectionStatus$1;
+type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 /**
- * Thread context value - the public interface returned by useThread()
+ * Thread context value
  */
 interface ThreadContextValue {
     /** The thread ID */
     threadId: string;
     /** Current messages in the thread */
     messages: Message[];
-    /** Messages transformed to workblocks (if useWorkblocks is true) */
-    workblocks: ThreadMessage[];
-    /** Whether messages are currently loading (alias: isLoading) */
+    /** Whether messages are currently loading */
     loading: boolean;
-    /** Whether messages are currently loading (alias for loading) */
-    isLoading: boolean;
     /** Any error that occurred */
     error: Error | null;
-    /** WebSocket connection status (alias: status) */
+    /** WebSocket connection status */
     connectionStatus: ConnectionStatus;
-    /** WebSocket connection status (alias for connectionStatus) */
-    status: ConnectionStatus;
-    /** Subscribe to a specific event type (alias: onEvent) */
+    /** Subscribe to a specific event type */
     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 */
-    sendMessage: (payload: SendMessagePayload) => 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 */
-    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;
 }
 interface ThreadProviderProps {
     /** The thread ID to connect to */
@@ -93,8 +184,6 @@ 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) */
@@ -118,10 +207,8 @@ interface ThreadProviderProps {
  * </AgentBuilderProvider>
  * ```
  */
-declare function ThreadProvider({ threadId, options, preload, live, useWorkblocks, depth, includeSilent, endpoint: endpointOverride, children, }: ThreadProviderProps): react_jsx_runtime.JSX.Element;
+declare function ThreadProvider({ threadId, options, preload, live, 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.
  *
@@ -135,24 +222,23 @@ declare function useThreadContext(): ThreadContextValue;
 declare function useThreadId(): string;
 
 /**
- * Hook to access the thread context.
+ * Hook to get messages from a thread.
  *
- * Must be used within a ThreadProvider. Returns the full thread context
- * including messages, actions, and file management.
+ * Must be used within a ThreadProvider. The thread ID and WebSocket connection
+ * are managed by the ThreadProvider, so this hook simply returns the messages.
  *
- * @returns The thread context value
+ * @param options - Configuration options
+ * @returns Array of messages (raw or transformed to workblocks)
  *
  * @example
  * ```tsx
  * function ChatMessages() {
- *   const { messages, sendMessage, files } = useThread()
+ *   // Basic usage - returns messages from context
+ *   const messages = useThread()
  *
  *   return (
  *     <div>
  *       {messages.map(msg => <Message key={msg.id} message={msg} />)}
- *       <button onClick={() => sendMessage({ role: 'user', content: 'Hello!' })}>
- *         Send
- *       </button>
  *     </div>
  *   )
  * }
@@ -162,8 +248,14 @@ declare function useThreadId(): string;
  *   <ChatMessages />
  * </ThreadProvider>
  * ```
+ *
+ * @example
+ * ```tsx
+ * // Disable workblocks transformation
+ * const messages = useThread({ useWorkblocks: false })
+ * ```
  */
-declare function useThread(): ThreadContextValue;
+declare function useThread(options?: UseThreadOptions): ThreadMessage[];
 
 /**
  * Hook to listen for custom events emitted from a thread via the stream WebSocket.
@@ -247,8 +339,6 @@ 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.
  *
@@ -261,20 +351,23 @@ declare function useThreadEvent<T = unknown>(type: string): T | null;
  *
  * @example
  * ```tsx
- * // NEW - Recommended
- * const { sendMessage } = useThread()
- * await sendMessage({ role: 'user', content: 'Hello!' })
+ * function ChatInput() {
+ *   const sendMessage = useSendMessage()
+ *
+ *   const handleSubmit = async (content: string) => {
+ *     await sendMessage({
+ *       role: 'user',
+ *       content,
+ *     })
+ *   }
  *
- * // OLD - Deprecated
- * const sendMessage = useSendMessage()
- * await sendMessage({ role: 'user', content: 'Hello!' })
+ *   return <input onSubmit={handleSubmit} />
+ * }
  * ```
  */
 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.
  *
@@ -287,13 +380,15 @@ declare function useSendMessage(): (payload: SendMessagePayload) => Promise<Mess
  *
  * @example
  * ```tsx
- * // NEW - Recommended
- * const { stopExecution } = useThread()
- * await stopExecution()
+ * function StopButton() {
+ *   const stopThread = useStopThread()
  *
- * // OLD - Deprecated
- * const stopThread = useStopThread()
- * await stopThread()
+ *   return (
+ *     <button onClick={() => stopThread()}>
+ *       Stop
+ *     </button>
+ *   )
+ * }
  * ```
  */
 declare function useStopThread(): () => Promise<void>;
@@ -365,4 +460,4 @@ interface StopThreadOptions {
  */
 declare function stopThread(id: string, options?: StopThreadOptions): Promise<void>;
 
-export { AgentBuilderProvider, type ConnectionStatus, type ThreadContextValue, ThreadProvider, type ThreadProviderOptions, onThreadEvent, sendMessage, stopThread, useSendMessage, useStopThread, useThread, useThreadContext, useThreadEvent, useThreadId };
+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 };