@cadraos/sdk 0.1.3 → 0.1.5

package/dist/chat/index.d.cts

@@ -1,256 +1,28 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as React from 'react';
+import { Components } from 'react-markdown';
+import * as React$1 from 'react';
 
-/**
- * ChatAdapter interface for customizable API integration
- *
- * Implement this interface to:
- * - Connect to different backends
- * - Use direct DB access (in ai-saas-v2)
- * - Mock for testing
- *
- * @module @cadraos/sdk/chat
- */
-/**
- * Input for starting an agent execution
- */
-interface StartExecutionInput {
-    /** UUID of the agent to execute */
-    agentId: string;
-    /** Optional session ID for continuing a conversation */
-    sessionId?: string;
-    /** User message content */
-    content: string;
-    /** UUIDs of attached files */
-    attachmentUuids?: string[];
-}
-/**
- * Input for sending a message in an existing session
- */
-interface SendMessageInput {
-    /** Session ID */
-    sessionId: string;
-    /** Message content */
-    content: string;
-    /** UUIDs of attached files */
-    attachmentUuids?: string[];
-}
-/**
- * Input for getting an upload URL
- */
-interface UploadUrlInput {
-    /** Session ID */
-    sessionId: string;
-    /** Filename */
-    filename: string;
-    /** MIME type */
-    mimeType: string;
-    /** File size in bytes */
-    size: number;
-}
-/**
- * Result from starting an execution
- */
-interface ExecutionResult {
-    /** UUID of the created execution */
-    executionId: string;
-    /** UUID of the session (new or existing) */
-    sessionId: string;
-}
-/**
- * Result from getting an upload URL
- */
-interface UploadUrlResult {
-    /** Pre-signed upload URL */
-    uploadUrl: string;
-    /** UUID for the attachment */
-    attachmentUuid: string;
-}
-/**
- * Execution status and result
- */
-interface Execution {
-    /** Execution UUID */
-    uuid: string;
-    /** Current status */
-    status: "pending" | "running" | "completed" | "failed" | "cancelled";
-    /** Final result (when completed) */
-    result?: string;
-    /** Error message (when failed) */
-    error?: string;
-}
-/**
- * Artifact generated during execution
- */
-interface Artifact {
-    /** Artifact UUID */
-    uuid: string;
-    /** Artifact type */
-    type: "image" | "document" | "code" | "audio";
-    /** Filename */
-    filename: string;
-    /** MIME type */
-    mimeType: string;
-    /** Download URL */
-    url: string;
-}
-/**
- * Attachment metadata for history messages
- */
-interface HistoryAttachment {
-    /** Attachment UUID */
-    uuid: string;
-    /** Original filename */
-    filename: string;
-    /** MIME type */
-    mimeType: string;
-    /** File size in bytes */
-    size: number;
-    /** Category classification */
-    category: "document" | "image" | "audio";
-    /** Preview URL (for images) */
-    previewUrl?: string;
-    /** Thumbnail URL */
-    thumbnailUrl?: string;
-}
-/**
- * Tool call data for history messages
- */
-interface HistoryToolCall {
-    /** Tool call ID */
-    id: string;
-    /** Tool name */
-    name: string;
-    /** Tool arguments */
-    args?: Record<string, unknown>;
-    /** Tool result */
-    result?: unknown;
-    /** Execution status */
-    status: "pending" | "running" | "completed" | "failed";
-    /** Execution duration in ms */
-    durationMs?: number;
-}
-/**
- * A message in the session history
- */
-interface HistoryMessage {
-    /** Message UUID */
-    uuid: string;
-    /** Message role */
-    role: "user" | "assistant";
-    /** Message content */
+interface MarkdownContentProps {
+    /** Markdown content to render */
     content: string;
-    /** Message timestamp */
-    timestamp: string;
-    /** File attachments (for user messages) */
-    attachments?: HistoryAttachment[];
-    /** Tool calls (for assistant messages) */
-    toolCalls?: HistoryToolCall[];
-}
-/**
- * Session with chat history
- */
-interface SessionHistory {
-    /** Session UUID */
-    sessionId: string;
-    /** Agent UUID */
-    agentId: string;
-    /** Messages in chronological order */
-    messages: HistoryMessage[];
-    /** When the session was created */
-    createdAt: string;
-    /** When the session was last updated */
-    updatedAt: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom React-Markdown component overrides (merged with defaults, user wins) */
+    components?: Partial<Components>;
+    /** Custom URL transform for React-Markdown (e.g., to preserve custom protocols like artifact:) */
+    urlTransform?: (url: string) => string;
+    /** Transform content string before rendering (e.g., strip certain patterns) */
+    contentTransform?: (content: string) => string;
 }
 /**
- * ChatAdapter interface for API integration
- *
- * This interface decouples the UI from the API implementation,
- * allowing:
- * - Built-in HTTP adapter for external API consumers
- * - Custom adapter for ai-saas-v2 (direct tRPC/DB access)
- * - Testing with mock adapters
+ * Renders markdown content with chat-appropriate styling
  *
  * @example
- * ```typescript
- * // Using default HTTP adapter
- * const adapter = createDefaultAdapter({
- *   baseUrl: 'https://api.example.com/api/v1/external',
- *   apiKey: 'your-api-key',
- *   orgId: 123,
- * });
- *
- * // Using custom tRPC adapter
- * const adapter: ChatAdapter = {
- *   startExecution: (input) => api.agents.execute.mutate(input),
- *   // ... other methods
- * };
+ * ```tsx
+ * <MarkdownContent content="# Hello\n\nThis is **bold** text." />
  * ```
  */
-interface ChatAdapter {
-    /**
-     * Start a new agent execution
-     * @param input - Execution input
-     * @returns Execution and session IDs
-     */
-    startExecution(input: StartExecutionInput): Promise<ExecutionResult>;
-    /**
-     * Send a message in an existing session
-     * @param input - Message input
-     * @returns Execution and session IDs
-     */
-    sendMessage(input: SendMessageInput): Promise<ExecutionResult>;
-    /**
-     * Cancel a running execution
-     * @param uuid - Execution UUID
-     */
-    cancelExecution(uuid: string): Promise<void>;
-    /**
-     * Get execution status and result
-     * @param uuid - Execution UUID
-     * @returns Execution details
-     */
-    getExecution(uuid: string): Promise<Execution>;
-    /**
-     * Get a pre-signed URL for uploading a file
-     * @param input - Upload URL input
-     * @returns Upload URL and attachment UUID
-     */
-    getUploadUrl(input: UploadUrlInput): Promise<UploadUrlResult>;
-    /**
-     * Confirm that a file upload has completed
-     * @param uuid - Attachment UUID
-     */
-    confirmUpload(uuid: string): Promise<void>;
-    /**
-     * Get a download URL for an attachment
-     * @param uuid - Attachment UUID
-     * @returns Signed download URL
-     */
-    getDownloadUrl(uuid: string): Promise<string>;
-    /**
-     * Get artifacts generated in a session
-     * @param sessionId - Session UUID
-     * @returns List of artifacts
-     */
-    getSessionArtifacts?(sessionId: string): Promise<Artifact[]>;
-    /**
-     * Load chat history for an existing session
-     *
-     * This method is optional. If not implemented, session loading will not be available.
-     * The returned data is designed to be cacheable with React Query, SWR, or Next.js caching.
-     *
-     * @param sessionId - Session UUID
-     * @returns Session with message history
-     */
-    getSessionHistory?(sessionId: string): Promise<SessionHistory>;
-    /**
-     * Get the SSE stream URL for an execution
-     * @param executionId - Execution UUID
-     * @returns Full URL for SSE connection
-     */
-    getStreamUrl(executionId: string): string;
-}
+declare function MarkdownContent({ content, className, components: customComponents, urlTransform, contentTransform, }: MarkdownContentProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Type definitions for @cadraos/sdk/chat
@@ -332,168 +104,2569 @@ interface ThinkingBlock {
 /**
  * Chat error information
  */
-interface ChatError {
-    /** Error code for programmatic handling */
-    code: string;
-    /** Human-readable error message */
-    message: string;
-    /** Additional error details */
-    details?: Record<string, unknown>;
-    /** Whether the error is retryable */
-    retryable?: boolean;
-}
+interface ChatError {
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+    /** Whether the error is retryable */
+    retryable?: boolean;
+}
+/**
+ * Data for agent clarification requests (ask_user tool)
+ */
+interface ClarificationData {
+    /** The question being asked */
+    question: string;
+    /** Optional reason for asking */
+    reason?: string;
+    /** Suggested response options */
+    suggestedOptions?: string[];
+}
+/**
+ * Todo item for agent task lists
+ */
+interface TodoItem {
+    /** Task description (imperative form) */
+    content: string;
+    /** Current status */
+    status: "pending" | "in_progress" | "completed";
+    /** Present continuous form for active display */
+    activeForm: string;
+}
+/**
+ * SSE stream event from agent execution
+ */
+interface ExecutionStreamEvent {
+    /** Event type */
+    type: string;
+    /** Unique event ID for deduplication */
+    id: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Event data payload */
+    data: {
+        type?: string;
+        log?: {
+            stepIndex: number;
+            logType: string;
+            message: string;
+            metadata: Record<string, unknown>;
+            timestamp: string;
+            durationMs?: number;
+        };
+        executionId?: string;
+        toolName?: string;
+        args?: unknown;
+        iteration?: number;
+        tokenUsage?: {
+            prompt: number;
+            completion: number;
+            total: number;
+        };
+        cost?: number;
+        error?: string;
+        question?: string;
+        reason?: string;
+        suggestedOptions?: string[];
+        redisAvailable?: boolean;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Theme mode options
+ */
+type ThemeMode = "light" | "dark" | "system";
+/**
+ * Attachment file for upload
+ */
+interface AttachmentFile {
+    /** File UUID after upload */
+    uuid: string;
+    /** Original file object */
+    file: File;
+    /** Upload status */
+    status: "pending" | "uploading" | "ready" | "failed";
+    /** Preview URL for local display */
+    previewUrl?: string;
+    /** Progress percentage (0-100) */
+    progress?: number;
+}
+
+interface ChatMessageProps {
+    /** Message data */
+    message: ChatMessage$1;
+    /** Whether to enable markdown rendering */
+    enableMarkdown?: boolean;
+    /** Whether to show tool calls */
+    showToolCalls?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom markdown component overrides */
+    markdownComponents?: Parameters<typeof MarkdownContent>[0]["components"];
+    /** Custom URL transform for markdown */
+    markdownUrlTransform?: (url: string) => string;
+    /** Custom content transform for markdown */
+    markdownContentTransform?: (content: string) => string;
+    /** Optional callback when an image in a tool call result is clicked */
+    onImageClick?: (image: {
+        url: string;
+        alt?: string;
+        filename?: string;
+    }) => void;
+}
+/**
+ * Renders a single chat message with appropriate styling
+ *
+ * @example
+ * ```tsx
+ * <ChatMessage
+ *   message={{
+ *     id: "1",
+ *     role: "assistant",
+ *     content: "Hello! How can I help?",
+ *     timestamp: new Date(),
+ *   }}
+ *   enableMarkdown
+ *   showToolCalls
+ * />
+ * ```
+ */
+declare function ChatMessage({ message, enableMarkdown, showToolCalls, className, markdownComponents, markdownUrlTransform, markdownContentTransform, onImageClick, }: ChatMessageProps): react_jsx_runtime.JSX.Element;
+
+interface MessageListProps {
+    /** Array of messages to display */
+    messages: ChatMessage$1[];
+    /** Welcome message shown when chat is empty */
+    welcomeMessage?: string;
+    /**
+     * Custom welcome UI rendered when chat is empty (no messages).
+     * When provided, replaces the default centered text welcome message.
+     * Takes precedence over `welcomeMessage` string prop.
+     *
+     * Can be a ReactNode or a render function receiving `{ sendMessage }`
+     * to allow interactive elements (e.g., suggestion chips) to send messages.
+     */
+    renderWelcome?: React.ReactNode | ((props: {
+        sendMessage: (text: string) => void;
+    }) => React.ReactNode);
+    /** Whether a new message is loading */
+    isLoading?: boolean;
+    /** Whether the assistant is currently streaming a response */
+    isStreaming?: boolean;
+    /** Whether session history is being loaded */
+    isLoadingHistory?: boolean;
+    /** Whether to enable markdown rendering */
+    enableMarkdown?: boolean;
+    /** Whether to show tool calls */
+    showToolCalls?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom markdown component overrides */
+    markdownComponents?: ChatMessageProps["markdownComponents"];
+    /** Custom URL transform for markdown */
+    markdownUrlTransform?: (url: string) => string;
+    /** Custom content transform for markdown */
+    markdownContentTransform?: (content: string) => string;
+    /** Optional callback when an image in a tool call result is clicked */
+    onImageClick?: (image: {
+        url: string;
+        alt?: string;
+        filename?: string;
+    }) => void;
+    /**
+     * Send message function passed from parent (AgentChat).
+     * Used to forward to renderWelcome render function for suggestion chips.
+     * @internal
+     */
+    sendMessage?: (text: string) => void;
+}
+/**
+ * Renders a scrollable list of chat messages with auto-scroll
+ *
+ * @example
+ * ```tsx
+ * <MessageList
+ *   messages={messages}
+ *   welcomeMessage="Hello! How can I help you today?"
+ *   isLoading={isLoading}
+ *   isStreaming={isStreaming}
+ *   enableMarkdown
+ *   showToolCalls
+ * />
+ * ```
+ */
+declare function MessageList({ messages, welcomeMessage, renderWelcome, isLoading, isStreaming, isLoadingHistory, enableMarkdown, showToolCalls, className, markdownComponents, markdownUrlTransform, markdownContentTransform, onImageClick, sendMessage, }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Common types shared across all resources
+ */
+/**
+ * JSON Schema type for tool input/output schemas
+ */
+type JSONSchema = {
+    type: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    description?: string;
+    [key: string]: unknown;
+};
+/**
+ * Pagination options for list operations
+ */
+interface ListOptions {
+    /** Maximum number of items to return (default: 20) */
+    limit?: number;
+    /** Number of items to skip (pagination offset) */
+    offset?: number;
+    /** Field to sort by (e.g., 'createdAt') */
+    sort?: string;
+    /** Sort order */
+    order?: 'asc' | 'desc';
+}
+/**
+ * Pagination metadata in list responses
+ */
+interface PaginationInfo {
+    /** Total number of items */
+    total: number;
+    /** Number of items returned */
+    limit: number;
+    /** Number of items skipped */
+    offset: number;
+    /** Whether there are more items */
+    hasMore: boolean;
+}
+/**
+ * Paginated list response
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: PaginationInfo;
+}
+/**
+ * Execute operation options
+ */
+interface ExecuteOptions {
+    /** Maximum number of agent iterations */
+    maxIterations?: number;
+    /** Maximum tokens for the response */
+    maxTokens?: number;
+    /** Execution timeout in milliseconds */
+    timeout?: number;
+    /** Idempotency key for retry safety */
+    idempotencyKey?: string;
+}
+/**
+ * Execute input for agent/skill operations
+ */
+interface ExecuteInput {
+    /** The task or prompt to execute */
+    task: string;
+    /** Additional context for the execution */
+    context?: Record<string, unknown>;
+    /** Attachment UUIDs to include with the message (for images, documents, etc.) */
+    attachmentIds?: string[];
+    /** Team UUID for team-based execution (routes to team's lead orchestrator) */
+    teamUuid?: string;
+    /** Execution options */
+    options?: ExecuteOptions;
+}
+/**
+ * Execution status
+ */
+type ExecutionStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'paused' | 'waiting_user_input';
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    /** Input tokens consumed */
+    input: number;
+    /** Output tokens generated */
+    output: number;
+    /** Total tokens */
+    total: number;
+}
+
+/**
+ * Agent types
+ */
+
+/**
+ * Agent type
+ */
+type AgentType = 'simple' | 'workflow' | 'orchestrator';
+/**
+ * Agent status
+ */
+type AgentStatus = 'active' | 'inactive' | 'draft';
+/**
+ * Agent configuration
+ */
+interface AgentConfig {
+    /** LLM model to use */
+    model?: string;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Maximum iterations for agent loop */
+    maxIterations?: number;
+    /** System prompt for the agent */
+    systemPrompt?: string;
+}
+/**
+ * Agent resource
+ */
+interface Agent {
+    /** Unique identifier */
+    uuid: string;
+    /** Agent name */
+    name: string;
+    /** Agent description */
+    description: string | null;
+    /** Agent type */
+    type: AgentType;
+    /** Agent status */
+    status: AgentStatus;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Agent configuration (included in get, not list) */
+    config?: AgentConfig;
+}
+/**
+ * Agent list options
+ */
+interface AgentListOptions extends ListOptions {
+    /** Filter by status */
+    status?: AgentStatus;
+    /** Filter by type */
+    type?: AgentType;
+}
+/**
+ * Log types that can be generated during execution
+ * Matches the LogType from cadra-api's log-collector service
+ */
+type LogType = 'info' | 'llm_request' | 'llm_response' | 'tool_call' | 'tool_result' | 'error' | 'system' | 'think' | 'rag' | 'skill' | 'delegation' | 'plan' | 'message';
+/**
+ * Execution log entry
+ */
+interface ExecutionLog {
+    /** Unique identifier */
+    uuid: string;
+    /** Log type */
+    type: LogType;
+    /** Log title/summary */
+    title: string;
+    /** Log content/details */
+    content?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: string;
+    /** Duration in milliseconds (if applicable) */
+    durationMs?: number;
+}
+/**
+ * Agent execution result
+ */
+interface AgentExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Agent ID */
+    agentUuid: string;
+    /** Session ID for conversation continuity */
+    sessionId?: string;
+    /** Execution status */
+    status: ExecutionStatus;
+    /** Input provided */
+    input: {
+        task: string;
+        context?: Record<string, unknown>;
+    };
+    /** Output result */
+    output?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Execution logs */
+    logs: ExecutionLog[];
+    /** Token usage */
+    tokenUsage?: TokenUsage;
+    /** Cost in USD */
+    cost?: number;
+    /** Number of iterations */
+    iterations?: number;
+    /** When execution was queued */
+    queuedAt: string;
+    /** When execution started */
+    startedAt?: string;
+    /** When execution completed */
+    completedAt?: string;
+    /** Total duration in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Agent update input
+ */
+interface AgentUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New status */
+    status?: AgentStatus;
+}
+/**
+ * Agent config update input
+ */
+interface AgentConfigUpdateInput {
+    /** LLM model */
+    model?: string;
+    /** Temperature */
+    temperature?: number;
+    /** Max iterations */
+    maxIterations?: number;
+    /** System prompt */
+    systemPrompt?: string;
+}
+/**
+ * Execute response (async)
+ */
+interface ExecuteResponse {
+    /** Execution ID */
+    executionId: string;
+    /** Session ID for conversation continuity */
+    sessionId?: string;
+    /** Initial status */
+    status: ExecutionStatus;
+}
+
+/**
+ * Streaming types
+ */
+
+/**
+ * Tool call event
+ */
+interface ToolCallEvent {
+    /** Tool call ID */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Tool inputs */
+    inputs: Record<string, unknown>;
+    /** Step/iteration index */
+    stepIndex: number;
+}
+/**
+ * Tool result event
+ */
+interface ToolResultEvent {
+    /** Tool call ID */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Tool result */
+    result: unknown;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Plan event
+ */
+interface PlanEvent {
+    /** Planned tasks */
+    tasks: Array<{
+        title: string;
+        status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    }>;
+}
+/**
+ * Complete event
+ */
+interface CompleteEvent {
+    /** Final execution result */
+    execution: AgentExecution;
+}
+/**
+ * Error event
+ */
+interface ErrorEvent {
+    /** Error message */
+    error: string;
+    /** Error code */
+    errorCode?: string;
+}
+/**
+ * Connection change event
+ */
+interface ConnectionChangeEvent {
+    /** Whether connected */
+    connected: boolean;
+    /** Whether using fallback polling */
+    usingFallback?: boolean;
+}
+/**
+ * Paused event (ask_user waiting for user input)
+ */
+interface PausedEvent {
+    /** The question to ask the user */
+    question: string;
+    /** Optional predefined choices */
+    options?: string[];
+    /** Reason for pausing */
+    reason: 'waiting_user_input';
+}
+/**
+ * Delegation started event (handoff_to_agent initiated)
+ */
+interface DelegationStartedEvent {
+    /** Event type */
+    type: 'delegation_started';
+    /** Unique handoff ID */
+    handoffId: string;
+    /** Target agent UUID */
+    targetAgentUuid: string;
+    /** Target agent name */
+    targetAgentName?: string;
+    /** Preview of the delegated task */
+    taskPreview: string;
+    /** Event timestamp */
+    timestamp: string;
+}
+/**
+ * Delegation completed event (handoff_to_agent finished)
+ */
+interface DelegationCompletedEvent {
+    /** Event type */
+    type: 'delegation_completed';
+    /** Unique handoff ID */
+    handoffId: string;
+    /** Completion status */
+    status: 'completed' | 'failed';
+    /** Preview of the result (if completed) */
+    resultPreview?: string;
+    /** Error message (if failed) */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Event timestamp */
+    timestamp: string;
+}
+/**
+ * Text delta event - token-by-token streaming text
+ */
+interface TextDeltaEvent {
+    /** Text delta chunk */
+    delta: string;
+    /** Execution ID */
+    executionId: string;
+    /** Event timestamp */
+    timestamp: string;
+}
+/**
+ * Started event - execution has begun
+ */
+interface StartedEvent {
+    /** Execution ID */
+    executionId: string;
+    /** Agent UUID */
+    agentUuid: string;
+    /** Initial status */
+    status: 'initializing';
+    /** Current step description */
+    currentStep?: string;
+}
+/**
+ * Progress event - execution status update
+ */
+interface ProgressEvent {
+    /** Current status */
+    status: 'initializing' | 'thinking' | 'acting' | 'observing' | 'planning' | 'paused';
+    /** Current iteration number */
+    iteration: number;
+    /** Description of current step */
+    currentStep?: string;
+    /** Current token usage */
+    tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    /** Current cost */
+    cost?: number;
+    /** Number of tool calls made */
+    toolCalls?: number;
+}
+/**
+ * Task status for task list updates
+ */
+type TaskStatus = 'pending' | 'in_progress' | 'completed';
+/**
+ * Task item in task list
+ */
+interface TaskItem {
+    /** Unique task ID */
+    id: string;
+    /** Task content/description */
+    content: string;
+    /** Active form text shown during in_progress */
+    activeForm?: string | null;
+    /** Task status */
+    status: TaskStatus;
+}
+/**
+ * Task list update event - agent creating/updating task list
+ */
+interface TaskListUpdateEvent {
+    /** Execution ID */
+    executionId: string;
+    /** Current task list */
+    tasks: TaskItem[];
+    /** Timestamp */
+    timestamp: string;
+}
+/**
+ * Stream controller interface
+ */
+interface StreamController {
+    /** Listen for log events */
+    on(event: 'log', callback: (log: ExecutionLog) => void): void;
+    /** Listen for tool call events */
+    on(event: 'toolCall', callback: (data: ToolCallEvent) => void): void;
+    /** Listen for tool result events */
+    on(event: 'toolResult', callback: (data: ToolResultEvent) => void): void;
+    /** Listen for plan updates */
+    on(event: 'plan', callback: (data: PlanEvent) => void): void;
+    /** Listen for paused events (ask_user waiting for input) */
+    on(event: 'paused', callback: (data: PausedEvent) => void): void;
+    /** Listen for execution started (immediate feedback) */
+    on(event: 'started', callback: (data: StartedEvent) => void): void;
+    /** Listen for progress updates (status changes during execution) */
+    on(event: 'progress', callback: (data: ProgressEvent) => void): void;
+    /** Listen for task list updates */
+    on(event: 'taskListUpdate', callback: (data: TaskListUpdateEvent) => void): void;
+    /** Listen for delegation started events */
+    on(event: 'delegationStarted', callback: (data: DelegationStartedEvent) => void): void;
+    /** Listen for delegation completed events */
+    on(event: 'delegationCompleted', callback: (data: DelegationCompletedEvent) => void): void;
+    /** Listen for text delta events (token-by-token streaming) */
+    on(event: 'textDelta', callback: (data: TextDeltaEvent) => void): void;
+    /** Listen for completion */
+    on(event: 'complete', callback: (data: CompleteEvent) => void): void;
+    /** Listen for errors */
+    on(event: 'error', callback: (error: ErrorEvent) => void): void;
+    /** Listen for connection state changes */
+    on(event: 'connectionChange', callback: (data: ConnectionChangeEvent) => void): void;
+    /** Cancel the stream */
+    cancel(): void;
+    /** Wait for completion, returns final execution result */
+    wait(): Promise<AgentExecution>;
+}
+
+/**
+ * Stream Controller
+ *
+ * Manages execution streaming with automatic reconnection and fallback to polling.
+ * Implements the StreamController interface for type-safe event handling.
+ */
+
+/**
+ * Execution Stream Controller
+ *
+ * Manages the lifecycle of an execution stream, including:
+ * - SSE connection management
+ * - Automatic reconnection with exponential backoff
+ * - Fallback to polling on connection failure
+ * - Event deduplication
+ */
+interface ExecutionStreamController extends StreamController {
+    /** Connect to the stream */
+    connect(): Promise<void>;
+    /** Get the execution ID */
+    readonly executionId: string;
+    /** Get the session ID (if available) */
+    readonly sessionId: string | undefined;
+}
+
+/**
+ * ChatAdapter interface for customizable API integration
+ *
+ * Implement this interface to:
+ * - Connect to different backends
+ * - Use direct DB access (in ai-saas-v2)
+ * - Mock for testing
+ *
+ * @module @cadraos/sdk/chat
+ */
+
+/**
+ * Input for starting an agent execution
+ */
+interface StartExecutionInput {
+    /** UUID of the agent to execute. Optional when teamId is provided. */
+    agentId?: string;
+    /** Optional team UUID for team-based execution (routes to team's lead orchestrator) */
+    teamId?: string;
+    /** Optional session ID for continuing a conversation */
+    sessionId?: string;
+    /** User message content */
+    content: string;
+    /** UUIDs of attached files */
+    attachmentUuids?: string[];
+}
+/**
+ * Input for sending a message in an existing session
+ */
+interface SendMessageInput$1 {
+    /** Session ID */
+    sessionId: string;
+    /** Message content */
+    content: string;
+    /** UUIDs of attached files */
+    attachmentUuids?: string[];
+}
+/**
+ * Input for getting an upload URL
+ */
+interface UploadUrlInput {
+    /** Session ID */
+    sessionId: string;
+    /** Filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Input for listing sessions
+ */
+interface ListSessionsInput {
+    /** Filter by agent UUID */
+    agentId?: string;
+    /** Maximum number of sessions to return */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+}
+/**
+ * Result from starting an execution
+ */
+interface ExecutionResult {
+    /** UUID of the created execution */
+    executionId: string;
+    /** UUID of the session (new or existing) */
+    sessionId: string;
+}
+/**
+ * Result from getting an upload URL
+ */
+interface UploadUrlResult {
+    /** Pre-signed upload URL */
+    uploadUrl: string;
+    /** UUID for the attachment */
+    attachmentUuid: string;
+}
+/**
+ * Execution status and result
+ */
+interface Execution {
+    /** Execution UUID */
+    uuid: string;
+    /** Current status */
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    /** Final result (when completed) */
+    result?: string;
+    /** Error message (when failed) */
+    error?: string;
+}
+/**
+ * Artifact generated during execution
+ */
+interface Artifact$1 {
+    /** Artifact UUID */
+    uuid: string;
+    /** Artifact type */
+    type: "image" | "document" | "code" | "audio";
+    /** Filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+    /** Download URL */
+    url: string;
+    /** When the artifact was created (ISO string) */
+    createdAt?: string;
+}
+/**
+ * Session summary for list display
+ */
+interface SessionListItem {
+    /** Session UUID */
+    id: string;
+    /** Agent UUID */
+    agentId: string;
+    /** When the session was created */
+    createdAt: string;
+    /** When the last message was sent */
+    lastMessageAt: string;
+    /** Total message count */
+    messageCount: number;
+    /** Preview of the last user message */
+    lastUserMessage?: string | null;
+}
+/**
+ * Paginated session list result
+ */
+interface SessionList {
+    /** Sessions in the current page */
+    sessions: SessionListItem[];
+    /** Total number of sessions */
+    total: number;
+    /** Whether there are more sessions beyond this page */
+    hasMore: boolean;
+}
+/**
+ * Attachment metadata for history messages
+ */
+interface HistoryAttachment {
+    /** Attachment UUID */
+    uuid: string;
+    /** Original filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+    /** Category classification */
+    category: "document" | "image" | "audio";
+    /** Preview URL (for images) */
+    previewUrl?: string;
+    /** Thumbnail URL */
+    thumbnailUrl?: string;
+}
+/**
+ * Tool call data for history messages
+ */
+interface HistoryToolCall {
+    /** Tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    args?: Record<string, unknown>;
+    /** Tool result */
+    result?: unknown;
+    /** Execution status */
+    status: "pending" | "running" | "completed" | "failed";
+    /** Execution duration in ms */
+    durationMs?: number;
+}
+/**
+ * A message in the session history
+ */
+interface HistoryMessage {
+    /** Message UUID */
+    uuid: string;
+    /** Message role */
+    role: "user" | "assistant";
+    /** Message content */
+    content: string;
+    /** Message timestamp */
+    timestamp: string;
+    /** File attachments (for user messages) */
+    attachments?: HistoryAttachment[];
+    /** Tool calls (for assistant messages) */
+    toolCalls?: HistoryToolCall[];
+}
+/**
+ * Session with chat history
+ */
+interface SessionHistory$1 {
+    /** Session UUID */
+    sessionId: string;
+    /** Agent UUID */
+    agentId: string;
+    /** Messages in chronological order */
+    messages: HistoryMessage[];
+    /** When the session was created */
+    createdAt: string;
+    /** When the session was last updated */
+    updatedAt: string;
+}
+/**
+ * ChatAdapter interface for API integration
+ *
+ * This interface decouples the UI from the API implementation,
+ * allowing:
+ * - Built-in HTTP adapter for external API consumers
+ * - Custom adapter for ai-saas-v2 (direct tRPC/DB access)
+ * - Testing with mock adapters
+ *
+ * @example
+ * ```typescript
+ * // Using default HTTP adapter
+ * const adapter = createDefaultAdapter({
+ *   baseUrl: 'https://api.example.com/api/v1/external',
+ *   apiKey: 'your-api-key',
+ *   orgId: 123,
+ * });
+ *
+ * // Using custom tRPC adapter
+ * const adapter: ChatAdapter = {
+ *   startExecution: (input) => api.agents.execute.mutate(input),
+ *   // ... other methods
+ * };
+ * ```
+ */
+interface ChatAdapter {
+    /**
+     * Start a new agent execution
+     * @param input - Execution input
+     * @returns Execution and session IDs
+     */
+    startExecution(input: StartExecutionInput): Promise<ExecutionResult>;
+    /**
+     * Send a message in an existing session
+     * @param input - Message input
+     * @returns Execution and session IDs
+     */
+    sendMessage(input: SendMessageInput$1): Promise<ExecutionResult>;
+    /**
+     * Cancel a running execution
+     * @param uuid - Execution UUID
+     */
+    cancelExecution(uuid: string): Promise<void>;
+    /**
+     * Get execution status and result
+     * @param uuid - Execution UUID
+     * @returns Execution details
+     */
+    getExecution(uuid: string): Promise<Execution>;
+    /**
+     * Get a pre-signed URL for uploading a file
+     * @param input - Upload URL input
+     * @returns Upload URL and attachment UUID
+     */
+    getUploadUrl(input: UploadUrlInput): Promise<UploadUrlResult>;
+    /**
+     * Confirm that a file upload has completed
+     * @param uuid - Attachment UUID
+     */
+    confirmUpload(uuid: string): Promise<void>;
+    /**
+     * Get a download URL for an attachment
+     * @param uuid - Attachment UUID
+     * @returns Signed download URL
+     */
+    getDownloadUrl(uuid: string): Promise<string>;
+    /**
+     * Get artifacts generated in a session
+     * @param sessionId - Session UUID
+     * @returns List of artifacts
+     */
+    getSessionArtifacts?(sessionId: string): Promise<Artifact$1[]>;
+    /**
+     * Load chat history for an existing session
+     *
+     * This method is optional. If not implemented, session loading will not be available.
+     * The returned data is designed to be cacheable with React Query, SWR, or Next.js caching.
+     *
+     * @param sessionId - Session UUID
+     * @returns Session with message history
+     */
+    getSessionHistory?(sessionId: string): Promise<SessionHistory$1>;
+    /**
+     * List sessions for the current user/agent
+     *
+     * @param input - List options (agent filter, pagination)
+     * @returns Paginated session list
+     */
+    listSessions?(input: ListSessionsInput): Promise<SessionList>;
+    /**
+     * Create an ExecutionStreamController for an execution.
+     *
+     * When implemented, useAgentChat will use this instead of the legacy
+     * EventSource-based useExecutionStream hook. The stream controller
+     * provides automatic reconnection, polling fallback, and event deduplication.
+     *
+     * @param executionId - Execution UUID to stream
+     * @param sessionId - Optional session ID for context
+     * @returns ExecutionStreamController instance (call .connect() to start)
+     */
+    createStream?(executionId: string, sessionId?: string): ExecutionStreamController;
+    /**
+     * Get the SSE stream URL for an execution.
+     *
+     * @deprecated Prefer implementing `createStream` which provides
+     * fetch-based SSE with auth headers. This is kept for backward
+     * compatibility with EventSource-based streaming.
+     *
+     * @param executionId - Execution UUID
+     * @returns Full URL for SSE connection
+     */
+    getStreamUrl?(executionId: string): string;
+}
+
+interface AgentChatProps {
+    /**
+     * The UUID of the agent to chat with.
+     * Optional when teamId is provided (team execution routes to team's lead orchestrator).
+     */
+    agentId?: string;
+    /** Optional team UUID for team-based execution (routes to team's lead orchestrator) */
+    teamId?: string;
+    /**
+     * Session ID to resume an existing conversation
+     * When provided, the component will load the session's chat history
+     */
+    sessionId?: string;
+    /** Custom adapter (optional - uses context if not provided) */
+    adapter?: ChatAdapter;
+    /** Callback fired when a new message is added */
+    onMessage?: (message: ChatMessage$1) => void;
+    /** Callback fired when an error occurs */
+    onError?: (error: ChatError) => void;
+    /**
+     * Callback fired when a new session is created
+     * Called with the sessionId when starting a new chat (no existing sessionId)
+     * Useful for updating external state like session lists
+     */
+    onSessionCreated?: (sessionId: string) => void;
+    /** @deprecated Use onSessionCreated instead */
+    onSessionStart?: (sessionId: string) => void;
+    /** Callback fired when a tool is called */
+    onToolCall?: (toolName: string, args: unknown) => void;
+    /** Callback fired when a tool result is received */
+    onToolResult?: (toolName: string, result: unknown, durationMs?: number) => void;
+    /** Callback fired when clarification is needed */
+    onClarification?: (data: ClarificationData) => void;
+    /** Initial messages to populate the chat */
+    initialMessages?: ChatMessage$1[];
+    /** Placeholder text for the input */
+    placeholder?: string;
+    /** Welcome message shown when chat is empty */
+    welcomeMessage?: string;
+    /**
+     * Custom welcome UI rendered when chat is empty (no messages).
+     * When provided, replaces the default centered text welcome message.
+     * Takes precedence over `welcomeMessage` string prop.
+     *
+     * Can be a ReactNode or a render function receiving `{ sendMessage }`
+     * to allow interactive elements (e.g., suggestion chips) to send messages.
+     */
+    renderWelcome?: React.ReactNode | ((props: {
+        sendMessage: (text: string) => void;
+    }) => React.ReactNode);
+    /** Maximum height of the chat container */
+    maxHeight?: string | number;
+    /** Additional CSS class for the container */
+    className?: string;
+    /** Theme mode */
+    theme?: ThemeMode;
+    /** Enable file attachments (future feature) */
+    enableAttachments?: boolean;
+    /** Enable markdown rendering */
+    enableMarkdown?: boolean;
+    /** Show tool call visualization */
+    showToolCalls?: boolean;
+    /** Custom markdown component overrides (e.g., for artifact rendering) */
+    markdownComponents?: MessageListProps["markdownComponents"];
+    /** Custom URL transform for markdown (e.g., to preserve artifact: protocol) */
+    markdownUrlTransform?: (url: string) => string;
+    /** Custom content transform for markdown */
+    markdownContentTransform?: (content: string) => string;
+    /** Optional callback when an image in a tool call result is clicked */
+    onImageClick?: (image: {
+        url: string;
+        alt?: string;
+        filename?: string;
+    }) => void;
+}
+/**
+ * Complete chat interface for interacting with AI agents
+ *
+ * @example
+ * ```tsx
+ * // With ChatConfigProvider (recommended for API key users)
+ * <ChatConfigProvider config={{ baseUrl: '...', apiKey: '...' }}>
+ *   <AgentChat
+ *     agentId="agent-uuid"
+ *     onMessage={(msg) => console.log('New message:', msg)}
+ *   />
+ * </ChatConfigProvider>
+ *
+ * // With custom adapter
+ * <AgentChat
+ *   agentId="agent-uuid"
+ *   adapter={myCustomAdapter}
+ * />
+ * ```
+ */
+declare function AgentChat({ agentId, teamId, sessionId, adapter, onMessage, onError, onSessionCreated, onSessionStart, onToolCall, onToolResult, onClarification, initialMessages, placeholder, welcomeMessage, renderWelcome, maxHeight, className, theme, enableAttachments, enableMarkdown, showToolCalls, markdownComponents, markdownUrlTransform, markdownContentTransform, onImageClick, }: AgentChatProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Retry utility with exponential backoff
+ */
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries: number;
+    /** Base delay in milliseconds (default: 1000) */
+    baseDelayMs: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs: number;
+    /** Jitter factor (0-1, default: 0.1) */
+    jitterFactor: number;
+}
+
+/**
+ * HTTP Client
+ *
+ * Handles all HTTP requests with authentication, retry logic, and error handling.
+ */
+
+/**
+ * HTTP Client configuration
+ */
+interface HttpClientConfig {
+    /** Base URL for API requests */
+    baseUrl: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** OAuth token for authentication */
+    token?: string;
+    /** Token provider callback (called before each request) */
+    tokenProvider?: () => Promise<string>;
+    /** Organization ID */
+    orgId: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout: number;
+    /** Retry configuration */
+    retry: RetryConfig;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Request options
+ */
+interface RequestOptions {
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
+    /** Request path (appended to base URL) */
+    path: string;
+    /** Request body */
+    body?: unknown;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean | undefined>;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Skip retry (for non-idempotent operations) */
+    skipRetry?: boolean;
+    /** Idempotency key */
+    idempotencyKey?: string;
+}
+/**
+ * HTTP Client class
+ */
+declare class HttpClient {
+    private config;
+    private tokenRefreshAttempts;
+    private readonly maxTokenRefreshAttempts;
+    constructor(config: HttpClientConfig);
+    /**
+     * Get authorization header value
+     */
+    private getAuthHeader;
+    /**
+     * Build full URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Make an HTTP request
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        skipRetry?: boolean;
+    }): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+    }): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string): Promise<T>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<HttpClientConfig>): void;
+}
+
+/**
+ * Skill types
+ */
+
+/**
+ * Skill tool reference
+ */
+interface SkillTool {
+    /** Tool UUID */
+    uuid: string;
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+}
+/**
+ * Skill variable definition
+ */
+interface SkillVariable {
+    /** Variable name */
+    name: string;
+    /** Variable type */
+    type: 'string' | 'number' | 'boolean' | 'object';
+    /** Variable description */
+    description: string;
+    /** Whether the variable is required */
+    required: boolean;
+    /** Default value */
+    default?: unknown;
+}
+/**
+ * Skill resource (list view)
+ */
+interface Skill {
+    /** Unique identifier */
+    uuid: string;
+    /** Skill name */
+    name: string;
+    /** Skill description */
+    description: string | null;
+    /** Category */
+    category: string | null;
+    /** Tags */
+    tags: string[];
+    /** Version string */
+    version: string;
+    /** Whether skill is public */
+    isPublic: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Skill details (get view, includes prompt template)
+ */
+interface SkillDetails extends Skill {
+    /** Prompt template */
+    promptTemplate: string;
+    /** Associated tools */
+    tools: SkillTool[];
+    /** Variable definitions */
+    variables: SkillVariable[];
+}
+/**
+ * Skill list options
+ */
+interface SkillListOptions extends ListOptions {
+    /** Filter by category */
+    category?: string;
+    /** Filter by tags (any match) */
+    tags?: string[];
+}
+/**
+ * Skill execute input
+ */
+interface SkillExecuteInput {
+    /** Variable values for the prompt template */
+    variables?: Record<string, unknown>;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/**
+ * Skill execution result
+ */
+interface SkillExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Skill ID */
+    skillUuid: string;
+    /** Execution status */
+    status: 'success' | 'error';
+    /** Input variables */
+    input: Record<string, unknown>;
+    /** Generated prompt output */
+    output?: string;
+    /** Error message */
+    error?: string;
+    /** Execution timestamp */
+    executedAt: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Skill update input
+ */
+interface SkillUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New category */
+    category?: string;
+    /** New tags */
+    tags?: string[];
+}
+
+/**
+ * Tool types
+ */
+
+/**
+ * Tool resource
+ */
+interface Tool {
+    /** Unique identifier */
+    uuid: string;
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Category */
+    category: string | null;
+    /** Input JSON schema */
+    inputSchema: JSONSchema;
+    /** Output JSON schema */
+    outputSchema?: JSONSchema;
+    /** Whether tool is enabled */
+    isEnabled: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Tool list options
+ */
+interface ToolListOptions extends ListOptions {
+    /** Filter by category */
+    category?: string;
+    /** Filter by enabled status */
+    isEnabled?: boolean;
+}
+/**
+ * Tool execution result
+ */
+interface ToolExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Tool ID */
+    toolUuid: string;
+    /** Execution status */
+    status: 'success' | 'error';
+    /** Input provided */
+    input: Record<string, unknown>;
+    /** Output result */
+    output?: unknown;
+    /** Error message */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Execution timestamp */
+    executedAt: string;
+}
+/**
+ * Tool input validation result
+ */
+interface ToolValidationResult {
+    /** Whether the input is valid */
+    valid: boolean;
+    /** Validation errors (if invalid) */
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+/**
+ * Tool update input
+ */
+interface ToolUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New category */
+    category?: string;
+}
+/**
+ * Tool config update input
+ */
+interface ToolConfigUpdateInput {
+    /** Tool-specific configuration */
+    config?: Record<string, unknown>;
+    /** Enable/disable tool */
+    isEnabled?: boolean;
+}
+
+/**
+ * Artifact types
+ */
+
+/**
+ * Artifact type
+ */
+type ArtifactType = 'file' | 'data' | 'log';
+/**
+ * Artifact resource
+ */
+interface Artifact {
+    /** Unique identifier */
+    uuid: string;
+    /** Associated execution ID */
+    executionUuid: string;
+    /** Artifact name */
+    name: string;
+    /** Artifact type */
+    type: ArtifactType;
+    /** MIME type */
+    mimeType: string;
+    /** Size in bytes */
+    size: number;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Artifact list options
+ */
+interface ArtifactListOptions extends ListOptions {
+    /** Filter by type */
+    type?: ArtifactType;
+}
+/**
+ * Artifact download options
+ */
+interface ArtifactDownloadOptions {
+    /** Response format (only for getSignedUrl) */
+    format?: 'buffer' | 'stream' | 'url';
+    /** Expiration time in seconds for signed URL (default: 3600) */
+    expiresIn?: number;
+}
+/**
+ * Signed URL response
+ */
+interface SignedUrlResponse {
+    /** The signed URL */
+    url: string;
+    /** When the URL expires */
+    expiresAt: string;
+}
+/**
+ * Artifact upload input
+ */
+interface ArtifactUploadInput {
+    /** File name */
+    name: string;
+    /** File content (Buffer in Node.js, Blob in browser) */
+    content: Buffer | Blob | ReadableStream<Uint8Array>;
+    /** MIME type */
+    mimeType?: string;
+    /** Artifact type */
+    type?: ArtifactType;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Session types
+ */
+
+/**
+ * Session resource
+ */
+interface Session {
+    /** Session ID */
+    id: string;
+    /** Associated agent ID */
+    agentUuid: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last message timestamp */
+    lastMessageAt: string;
+    /** Number of messages in session */
+    messageCount: number;
+    /** Last user message (for session list preview) */
+    lastUserMessage?: string | null;
+}
+/**
+ * Session message
+ */
+interface SessionMessage {
+    /** Message ID */
+    id: string;
+    /** Message role */
+    role: 'user' | 'assistant' | 'system';
+    /** Message content */
+    content: string;
+    /** Associated execution ID (for assistant messages) */
+    executionUuid?: string;
+    /** Message timestamp */
+    timestamp: string;
+}
+/**
+ * Session history with messages
+ */
+interface SessionHistory {
+    /** Session info */
+    session: Session;
+    /** Messages in chronological order */
+    messages: SessionMessage[];
+}
+/**
+ * Session list options
+ */
+interface SessionListOptions extends ListOptions {
+    /** Filter by agent */
+    agentUuid?: string;
+}
+/**
+ * Session create input
+ */
+interface SessionCreateInput {
+    /** Agent to associate with the session */
+    agentUuid: string;
+    /** Initial system message (optional) */
+    systemMessage?: string;
+}
+/**
+ * Send message input
+ */
+interface SendMessageInput {
+    /** Message content */
+    message: string;
+    /** Additional context */
+    context?: Record<string, unknown>;
+    /** Attachment UUIDs to include with the message (for images, documents, etc.) */
+    attachmentIds?: string[];
+}
+/**
+ * Session artifact type
+ */
+type SessionArtifactType = 'file' | 'image' | 'code' | 'data' | 'log' | 'report';
+/**
+ * Session artifact variant type
+ */
+type SessionArtifactVariantType = 'original' | 'thumbnail';
+/**
+ * Session artifact resource
+ * Represents an artifact generated during a session execution
+ */
+interface SessionArtifact {
+    /** Unique identifier */
+    uuid: string;
+    /** Associated execution ID */
+    executionId: string;
+    /** Artifact type */
+    type: SessionArtifactType;
+    /** Variant type (original or thumbnail) */
+    variantType: SessionArtifactVariantType;
+    /** Original filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+    /** Size in bytes */
+    size: number;
+    /** Pre-signed URL for accessing the artifact */
+    url: string;
+    /** Thumbnail URL (for images) */
+    thumbnailUrl?: string;
+    /** Image dimensions (for images) */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    /** Description */
+    description?: string | null;
+    /** Additional metadata */
+    metadata?: Record<string, unknown> | null;
+    /** Creation timestamp */
+    createdAt: string;
+}
+/**
+ * Session artifact list options
+ */
+interface SessionArtifactListOptions extends ListOptions {
+    /** Filter by artifact type */
+    type?: SessionArtifactType;
+    /** Include thumbnail variants (default: false) */
+    includeVariants?: boolean;
+}
+
+/**
+ * Base Resource API
+ *
+ * Abstract base class for all resource APIs.
+ * Provides common HTTP methods and path handling.
+ */
+
+/**
+ * Base Resource API class
+ */
+declare abstract class BaseResourceAPI {
+    protected readonly http: HttpClient;
+    protected readonly basePath: string;
+    constructor(http: HttpClient, basePath: string);
+    /**
+     * Build query parameters from list options
+     */
+    protected buildListQuery(options?: ListOptions): Record<string, string | number | boolean | undefined>;
+    /**
+     * HTTP GET request helper
+     */
+    protected httpGet<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * HTTP POST request helper
+     */
+    protected httpPost<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        skipRetry?: boolean;
+    }): Promise<T>;
+    /**
+     * HTTP PATCH request helper
+     */
+    protected httpPatch<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+    }): Promise<T>;
+    /**
+     * HTTP DELETE request helper
+     */
+    protected httpDelete<T>(path: string): Promise<T>;
+    /**
+     * List resources with pagination
+     */
+    protected listResources<T>(path: string, options?: ListOptions): Promise<PaginatedResponse<T>>;
+}
+
+/**
+ * Agents Resource API
+ *
+ * Provides all agent-related operations:
+ * - List: list(), get()
+ * - Execute: execute(), executeSync(), stream()
+ * - Receive: getExecution()
+ * - Edit: update(), updateConfig(), cancelExecution()
+ */
+
+/**
+ * Agents API class
+ */
+declare class AgentsAPI extends BaseResourceAPI {
+    private readonly getStreamConfig;
+    constructor(http: HttpClient, getStreamConfig: () => StreamConfig);
+    /**
+     * List all agents in the organization
+     *
+     * @param options - List options (pagination, filtering)
+     * @returns Paginated list of agents
+     *
+     * @example
+     * ```typescript
+     * const { data: agents, pagination } = await client.agents.list({ limit: 10 });
+     * ```
+     */
+    list(options?: AgentListOptions): Promise<PaginatedResponse<Agent>>;
+    /**
+     * Get a single agent by UUID
+     *
+     * @param uuid - Agent UUID
+     * @returns Agent with configuration
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.get('agent-uuid');
+     * console.log(agent.config);
+     * ```
+     */
+    get(uuid: string): Promise<Agent>;
+    /**
+     * Start an agent execution (async)
+     *
+     * Returns immediately with execution ID. Use getExecution() to poll
+     * for results, or use stream() for real-time updates.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input (task, context, options)
+     * @returns Execution ID and initial status
+     *
+     * @example
+     * ```typescript
+     * const { executionId, status } = await client.agents.execute('agent-uuid', {
+     *   task: 'Summarize the latest news about AI',
+     * });
+     * ```
+     */
+    execute(uuid: string, input: ExecuteInput): Promise<ExecuteResponse>;
+    /**
+     * Execute an agent and wait for completion (sync)
+     *
+     * Polls the execution status until completion or failure.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input
+     * @param pollInterval - Polling interval in ms (default: 1000)
+     * @returns Final execution result
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.executeSync('agent-uuid', {
+     *   task: 'Write a haiku about coding',
+     * });
+     * console.log(execution.output);
+     * ```
+     */
+    executeSync(uuid: string, input: ExecuteInput, pollInterval?: number): Promise<AgentExecution>;
+    /**
+     * Stream an agent execution
+     *
+     * Returns a StreamController for real-time event handling.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input
+     * @returns Stream controller for event handling
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.agents.stream('agent-uuid', {
+     *   task: 'Research climate change',
+     * });
+     *
+     * stream.on('log', (log) => console.log(log.title));
+     * stream.on('toolCall', ({ toolName }) => console.log(`Calling ${toolName}`));
+     * stream.on('complete', ({ execution }) => console.log(execution.output));
+     *
+     * const result = await stream.wait();
+     * ```
+     */
+    stream(uuid: string, input: ExecuteInput): Promise<ExecutionStreamController>;
+    /**
+     * Connect to an existing execution's stream
+     *
+     * Use this when the execution was started externally (e.g., via tRPC for team executions)
+     * and you need to connect to its SSE stream for real-time updates.
+     *
+     * @param executionId - Execution UUID (already running)
+     * @param sessionId - Optional session ID for conversation continuity
+     * @returns Stream controller for the execution
+     *
+     * @example
+     * ```typescript
+     * // Execution started via tRPC
+     * const executionId = await trpc.executions.start.mutate({ teamUuid, task });
+     *
+     * // Connect to SSE stream for real-time updates
+     * const stream = client.agents.streamExecution(executionId);
+     *
+     * stream.on('log', (log) => console.log(log.title));
+     * stream.on('delegationStarted', (data) => console.log('Subagent:', data.targetAgentName));
+     * stream.on('complete', ({ execution }) => console.log(execution.output));
+     *
+     * await stream.connect();
+     * const result = await stream.wait();
+     * ```
+     */
+    streamExecution(executionId: string, sessionId?: string): ExecutionStreamController;
+    /**
+     * Get execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Execution details including status, output, logs
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.getExecution('exec-uuid');
+     * if (execution.status === 'completed') {
+     *   console.log(execution.output);
+     * }
+     * ```
+     */
+    getExecution(executionId: string): Promise<AgentExecution>;
+    /**
+     * Update agent details
+     *
+     * @param uuid - Agent UUID
+     * @param data - Fields to update
+     * @returns Updated agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.update('agent-uuid', {
+     *   name: 'My Updated Agent',
+     *   description: 'New description',
+     * });
+     * ```
+     */
+    update(uuid: string, data: AgentUpdateInput): Promise<Agent>;
+    /**
+     * Update agent configuration
+     *
+     * @param uuid - Agent UUID
+     * @param config - Configuration fields to update
+     * @returns Updated agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.updateConfig('agent-uuid', {
+     *   temperature: 0.7,
+     *   maxIterations: 5,
+     * });
+     * ```
+     */
+    updateConfig(uuid: string, config: AgentConfigUpdateInput): Promise<Agent>;
+    /**
+     * Cancel a running execution
+     *
+     * @param executionId - Execution UUID
+     * @returns Updated execution with cancelled status
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.cancelExecution('exec-uuid');
+     * console.log(execution.status); // 'cancelled'
+     * ```
+     */
+    cancelExecution(executionId: string): Promise<AgentExecution>;
+    /**
+     * Poll execution until completion
+     */
+    private pollExecution;
+}
+/**
+ * Stream configuration passed from client
+ */
+interface StreamConfig {
+    baseUrl: string;
+    apiKey?: string;
+    token?: string;
+    tokenProvider?: () => Promise<string>;
+    orgId: number;
+}
+
+/**
+ * Skills Resource API
+ *
+ * Provides all skill-related operations:
+ * - List: list(), get(), getTools()
+ * - Execute: execute()
+ * - Receive: getExecution()
+ * - Edit: update(), updatePrompt()
+ */
+
+/**
+ * Skills API class
+ */
+declare class SkillsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List all skills in the organization
+     *
+     * @param options - List options (pagination, filtering by category/tags)
+     * @returns Paginated list of skills
+     *
+     * @example
+     * ```typescript
+     * const { data: skills } = await client.skills.list({
+     *   category: 'writing',
+     *   tags: ['seo', 'blog'],
+     * });
+     * ```
+     */
+    list(options?: SkillListOptions): Promise<PaginatedResponse<Skill>>;
+    /**
+     * Get a single skill by UUID with full details
+     *
+     * @param uuid - Skill UUID
+     * @returns Skill with prompt template and tools
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.get('skill-uuid');
+     * console.log(skill.promptTemplate);
+     * ```
+     */
+    get(uuid: string): Promise<SkillDetails>;
+    /**
+     * Get tools associated with a skill
+     *
+     * @param uuid - Skill UUID
+     * @returns Array of tools used by the skill
+     *
+     * @example
+     * ```typescript
+     * const tools = await client.skills.getTools('skill-uuid');
+     * tools.forEach(tool => console.log(tool.name));
+     * ```
+     */
+    getTools(uuid: string): Promise<SkillTool[]>;
+    /**
+     * Execute a skill with variables
+     *
+     * @param uuid - Skill UUID
+     * @param input - Variables and context for execution
+     * @returns Skill execution result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.skills.execute('skill-uuid', {
+     *   variables: {
+     *     topic: 'AI in healthcare',
+     *     tone: 'professional',
+     *   },
+     * });
+     * console.log(result.output);
+     * ```
+     */
+    execute(uuid: string, input: SkillExecuteInput): Promise<SkillExecution>;
+    /**
+     * Get skill execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Skill execution details
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.skills.getExecution('exec-uuid');
+     * ```
+     */
+    getExecution(executionId: string): Promise<SkillExecution>;
+    /**
+     * Update skill details
+     *
+     * @param uuid - Skill UUID
+     * @param data - Fields to update
+     * @returns Updated skill
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.update('skill-uuid', {
+     *   name: 'Updated Skill Name',
+     *   tags: ['new-tag'],
+     * });
+     * ```
+     */
+    update(uuid: string, data: SkillUpdateInput): Promise<Skill>;
+    /**
+     * Update skill prompt template
+     *
+     * @param uuid - Skill UUID
+     * @param prompt - New prompt template
+     * @returns Updated skill with new version
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.updatePrompt('skill-uuid',
+     *   'Write a {{tone}} article about {{topic}}...'
+     * );
+     * console.log(skill.version); // Version incremented
+     * ```
+     */
+    updatePrompt(uuid: string, prompt: string): Promise<SkillDetails>;
+}
+
+/**
+ * Tools Resource API
+ *
+ * Provides all tool-related operations:
+ * - List: list(), get()
+ * - Execute: execute(), validateInput()
+ * - Receive: getExecution()
+ * - Edit: update(), updateConfig()
+ */
+
+/**
+ * Tools API class
+ */
+declare class ToolsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List all tools in the organization
+     *
+     * @param options - List options (pagination, filtering)
+     * @returns Paginated list of tools
+     *
+     * @example
+     * ```typescript
+     * const { data: tools } = await client.tools.list({
+     *   category: 'data',
+     *   isEnabled: true,
+     * });
+     * ```
+     */
+    list(options?: ToolListOptions): Promise<PaginatedResponse<Tool>>;
+    /**
+     * Get a single tool by UUID with schema
+     *
+     * @param uuid - Tool UUID
+     * @returns Tool with input/output schemas
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.get('tool-uuid');
+     * console.log(tool.inputSchema);
+     * ```
+     */
+    get(uuid: string): Promise<Tool>;
+    /**
+     * Execute a tool directly
+     *
+     * @param uuid - Tool UUID
+     * @param input - Tool input (validated against inputSchema)
+     * @returns Tool execution result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.tools.execute('tool-uuid', {
+     *   query: 'weather in London',
+     *   limit: 5,
+     * });
+     * console.log(result.output);
+     * ```
+     */
+    execute(uuid: string, input: Record<string, unknown>): Promise<ToolExecution>;
+    /**
+     * Validate input against tool schema
+     *
+     * @param uuid - Tool UUID
+     * @param input - Input to validate
+     * @returns Validation result with errors if invalid
+     *
+     * @example
+     * ```typescript
+     * const validation = await client.tools.validateInput('tool-uuid', {
+     *   query: 'test',
+     * });
+     * if (!validation.valid) {
+     *   console.log(validation.errors);
+     * }
+     * ```
+     */
+    validateInput(uuid: string, input: Record<string, unknown>): Promise<ToolValidationResult>;
+    /**
+     * Get tool execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Tool execution details
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.tools.getExecution('exec-uuid');
+     * ```
+     */
+    getExecution(executionId: string): Promise<ToolExecution>;
+    /**
+     * Update tool details
+     *
+     * @param uuid - Tool UUID
+     * @param data - Fields to update
+     * @returns Updated tool
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.update('tool-uuid', {
+     *   name: 'Updated Tool Name',
+     *   description: 'New description',
+     * });
+     * ```
+     */
+    update(uuid: string, data: ToolUpdateInput): Promise<Tool>;
+    /**
+     * Update tool configuration
+     *
+     * @param uuid - Tool UUID
+     * @param config - Configuration to update
+     * @returns Updated tool
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.updateConfig('tool-uuid', {
+     *   isEnabled: false,
+     *   config: { apiKey: 'new-key' },
+     * });
+     * ```
+     */
+    updateConfig(uuid: string, config: ToolConfigUpdateInput): Promise<Tool>;
+}
+
+/**
+ * Artifacts Resource API
+ *
+ * Provides all artifact-related operations:
+ * - List: list(), get()
+ * - Receive: download(), downloadStream(), getSignedUrl()
+ * - Edit: upload(), delete()
+ */
+
+/**
+ * Artifacts API class
+ */
+declare class ArtifactsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List artifacts for an execution
+     *
+     * @param executionId - Execution UUID
+     * @param options - List options (pagination, filtering by type)
+     * @returns Paginated list of artifacts
+     *
+     * @example
+     * ```typescript
+     * const { data: artifacts } = await client.artifacts.list('exec-uuid', {
+     *   type: 'file',
+     * });
+     * ```
+     */
+    list(executionId: string, options?: ArtifactListOptions): Promise<PaginatedResponse<Artifact>>;
+    /**
+     * Get artifact metadata by UUID
+     *
+     * @param uuid - Artifact UUID
+     * @returns Artifact metadata
+     *
+     * @example
+     * ```typescript
+     * const artifact = await client.artifacts.get('artifact-uuid');
+     * console.log(artifact.name, artifact.size);
+     * ```
+     */
+    get(uuid: string): Promise<Artifact>;
+    /**
+     * Download artifact content
+     *
+     * In Node.js returns Buffer, in browser returns Blob.
+     *
+     * @param uuid - Artifact UUID
+     * @returns Artifact content as Buffer (Node.js) or Blob (browser)
+     *
+     * @example
+     * ```typescript
+     * const content = await client.artifacts.download('artifact-uuid');
+     * // Node.js: Buffer
+     * // Browser: Blob
+     * ```
+     */
+    download(uuid: string): Promise<Buffer | Blob>;
+    /**
+     * Download artifact as a stream
+     *
+     * In Node.js returns Readable stream, in browser returns ReadableStream.
+     *
+     * @param uuid - Artifact UUID
+     * @returns Readable stream
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.artifacts.downloadStream('artifact-uuid');
+     * // Pipe to file or process incrementally
+     * ```
+     */
+    downloadStream(uuid: string): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Get a signed URL for direct download
+     *
+     * @param uuid - Artifact UUID
+     * @param options - Options including expiration time
+     * @returns Signed URL and expiration time
+     *
+     * @example
+     * ```typescript
+     * const { url, expiresAt } = await client.artifacts.getSignedUrl('artifact-uuid', {
+     *   expiresIn: 3600, // 1 hour
+     * });
+     * // Use URL for direct download
+     * ```
+     */
+    getSignedUrl(uuid: string, options?: ArtifactDownloadOptions): Promise<SignedUrlResponse>;
+    /**
+     * Upload a new artifact for an execution
+     *
+     * @param executionId - Execution UUID
+     * @param input - Upload input (name, content, mime type)
+     * @returns Created artifact metadata
+     *
+     * @example
+     * ```typescript
+     * const artifact = await client.artifacts.upload('exec-uuid', {
+     *   name: 'report.pdf',
+     *   content: fileBuffer,
+     *   mimeType: 'application/pdf',
+     * });
+     * ```
+     */
+    upload(executionId: string, input: ArtifactUploadInput): Promise<Artifact>;
+    /**
+     * Delete an artifact
+     *
+     * @param uuid - Artifact UUID
+     *
+     * @example
+     * ```typescript
+     * await client.artifacts.delete('artifact-uuid');
+     * ```
+     */
+    delete(uuid: string): Promise<void>;
+}
+
+/**
+ * Sessions Resource API
+ *
+ * Provides all session-related operations:
+ * - List: list(), get()
+ * - Execute: sendMessage(), stream()
+ * - Receive: getHistory(), listArtifacts()
+ * - Edit: create(), delete()
+ */
+
+/**
+ * Sessions API class
+ */
+declare class SessionsAPI extends BaseResourceAPI {
+    private readonly getStreamConfig;
+    constructor(http: HttpClient, getStreamConfig: () => StreamConfig);
+    /**
+     * List all sessions in the organization
+     *
+     * @param options - List options (pagination, filtering by agent)
+     * @returns Paginated list of sessions
+     *
+     * @example
+     * ```typescript
+     * const { data: sessions } = await client.sessions.list({
+     *   agentUuid: 'agent-uuid',
+     * });
+     * ```
+     */
+    list(options?: SessionListOptions): Promise<PaginatedResponse<Session>>;
+    /**
+     * Get session details by ID
+     *
+     * @param sessionId - Session ID
+     * @returns Session details
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.get('session-id');
+     * console.log(session.messageCount);
+     * ```
+     */
+    get(sessionId: string): Promise<Session>;
+    /**
+     * Send a message to a session
+     *
+     * Triggers an agent execution in the context of the session.
+     * Returns immediately with execution ID. Use getHistory() to get
+     * the response, or use stream() for real-time updates.
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @returns Execution ID and status
+     *
+     * @example
+     * ```typescript
+     * const { executionId } = await client.sessions.sendMessage('session-id', {
+     *   message: 'What is the capital of France?',
+     * });
+     * ```
+     */
+    sendMessage(sessionId: string, input: SendMessageInput): Promise<ExecuteResponse>;
+    /**
+     * Send a message and wait for response (sync)
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @param pollInterval - Polling interval in ms (default: 1000)
+     * @returns Final execution result
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.sessions.sendMessageSync('session-id', {
+     *   message: 'What is the capital of France?',
+     * });
+     * console.log(execution.output);
+     * ```
+     */
+    sendMessageSync(sessionId: string, input: SendMessageInput, pollInterval?: number): Promise<AgentExecution>;
+    /**
+     * Stream a message response
+     *
+     * Returns a StreamController for real-time event handling.
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @returns Stream controller
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.sessions.stream('session-id', {
+     *   message: 'Tell me more about that',
+     * });
+     *
+     * stream.on('log', (log) => console.log(log.title));
+     * stream.on('complete', ({ execution }) => console.log(execution.output));
+     *
+     * const result = await stream.wait();
+     * ```
+     */
+    stream(sessionId: string, input: SendMessageInput): Promise<ExecutionStreamController>;
+    /**
+     * Get session conversation history
+     *
+     * @param sessionId - Session ID
+     * @returns Session with all messages
+     *
+     * @example
+     * ```typescript
+     * const history = await client.sessions.getHistory('session-id');
+     * history.messages.forEach(msg => {
+     *   console.log(`${msg.role}: ${msg.content}`);
+     * });
+     * ```
+     */
+    getHistory(sessionId: string): Promise<SessionHistory>;
+    /**
+     * List artifacts for a session
+     *
+     * Returns all artifacts generated across all executions in the session.
+     * Useful for retrieving images, files, and other outputs created during
+     * agent interactions.
+     *
+     * @param sessionId - Session ID
+     * @param options - List options (filtering by type, pagination)
+     * @returns Paginated list of session artifacts
+     *
+     * @example
+     * ```typescript
+     * // Get all images from a session
+     * const { data: artifacts } = await client.sessions.listArtifacts('session-id', {
+     *   type: 'image',
+     * });
+     *
+     * artifacts.forEach(artifact => {
+     *   console.log(artifact.filename, artifact.url);
+     * });
+     * ```
+     */
+    listArtifacts(sessionId: string, options?: SessionArtifactListOptions): Promise<PaginatedResponse<SessionArtifact>>;
+    /**
+     * Get execution result
+     */
+    private getExecution;
+    /**
+     * Create a new session for an agent
+     *
+     * @param agentUuid - Agent UUID to associate with session
+     * @param options - Optional system message
+     * @returns Created session
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.create({
+     *   agentUuid: 'agent-uuid',
+     *   systemMessage: 'You are a helpful assistant.',
+     * });
+     * console.log(session.id);
+     * ```
+     */
+    create(input: SessionCreateInput): Promise<Session>;
+    /**
+     * Delete a session and all its messages
+     *
+     * @param sessionId - Session ID
+     *
+     * @example
+     * ```typescript
+     * await client.sessions.delete('session-id');
+     * ```
+     */
+    delete(sessionId: string): Promise<void>;
+    /**
+     * Poll execution until completion
+     */
+    private pollExecution;
+}
+
+/**
+ * AI SaaS Client
+ *
+ * Main entry point for the SDK. Provides access to all resource APIs.
+ *
+ * @example
+ * ```typescript
+ * import { AISaaSClient } from '@cadraos/sdk';
+ *
+ * const client = new AISaaSClient({
+ *   apiKey: process.env.AISAAS_API_KEY,
+ *   orgId: Number(process.env.AISAAS_ORG_ID),
+ * });
+ *
+ * // List agents
+ * const { data: agents } = await client.agents.list();
+ *
+ * // Execute an agent
+ * const execution = await client.agents.executeSync(agents[0].uuid, {
+ *   task: 'Summarize the latest news',
+ * });
+ *
+ * // Stream an agent execution
+ * const stream = await client.agents.stream(agents[0].uuid, {
+ *   task: 'Research climate change',
+ * });
+ *
+ * stream.on('log', (log) => console.log(log.title));
+ * stream.on('complete', ({ execution }) => console.log(execution.output));
+ *
+ * const result = await stream.wait();
+ * ```
+ */
+
 /**
- * Data for agent clarification requests (ask_user tool)
+ * Client options for API key authentication
  */
-interface ClarificationData {
-    /** The question being asked */
-    question: string;
-    /** Optional reason for asking */
-    reason?: string;
-    /** Suggested response options */
-    suggestedOptions?: string[];
+interface AISaaSClientOptionsApiKey {
+    /** API key for authentication */
+    apiKey: string;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
 }
 /**
- * Todo item for agent task lists
+ * Client options for OAuth token authentication
  */
-interface TodoItem {
-    /** Task description (imperative form) */
-    content: string;
-    /** Current status */
-    status: "pending" | "in_progress" | "completed";
-    /** Present continuous form for active display */
-    activeForm: string;
+interface AISaaSClientOptionsToken {
+    /** OAuth token for authentication */
+    token: string;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
 }
 /**
- * SSE stream event from agent execution
+ * Client options for token provider authentication
  */
-interface ExecutionStreamEvent {
-    /** Event type */
-    type: string;
-    /** Unique event ID for deduplication */
-    id: string;
-    /** ISO timestamp */
-    timestamp: string;
-    /** Event data payload */
-    data: {
-        type?: string;
-        log?: {
-            stepIndex: number;
-            logType: string;
-            message: string;
-            metadata: Record<string, unknown>;
-            timestamp: string;
-            durationMs?: number;
-        };
-        executionId?: string;
-        toolName?: string;
-        args?: unknown;
-        iteration?: number;
-        tokenUsage?: {
-            prompt: number;
-            completion: number;
-            total: number;
-        };
-        cost?: number;
-        error?: string;
-        question?: string;
-        reason?: string;
-        suggestedOptions?: string[];
-        redisAvailable?: boolean;
-        [key: string]: unknown;
-    };
+interface AISaaSClientOptionsTokenProvider {
+    /** Token provider callback (called before each request) */
+    tokenProvider: () => Promise<string>;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
 }
 /**
- * Theme mode options
+ * All client options
  */
-type ThemeMode = "light" | "dark" | "system";
+type AISaaSClientOptions = AISaaSClientOptionsApiKey | AISaaSClientOptionsToken | AISaaSClientOptionsTokenProvider;
 /**
- * Attachment file for upload
+ * AI SaaS Client
+ *
+ * Main class for interacting with the AI SaaS API.
+ * Provides access to all resource APIs (agents, skills, tools, artifacts, sessions).
  */
-interface AttachmentFile {
-    /** File UUID after upload */
-    uuid: string;
-    /** Original file object */
-    file: File;
-    /** Upload status */
-    status: "pending" | "uploading" | "ready" | "failed";
-    /** Preview URL for local display */
-    previewUrl?: string;
-    /** Progress percentage (0-100) */
-    progress?: number;
-}
-
-interface AgentChatProps {
-    /** The UUID of the agent to chat with */
-    agentId: string;
+declare class AISaaSClient {
+    private readonly httpClient;
+    private readonly config;
     /**
-     * Session ID to resume an existing conversation
-     * When provided, the component will load the session's chat history
+     * Agent operations (list, execute, stream, update)
      */
-    sessionId?: string;
-    /** Custom adapter (optional - uses context if not provided) */
-    adapter?: ChatAdapter;
-    /** Callback fired when a new message is added */
-    onMessage?: (message: ChatMessage$1) => void;
-    /** Callback fired when an error occurs */
-    onError?: (error: ChatError) => void;
+    readonly agents: AgentsAPI;
     /**
-     * Callback fired when a new session is created
-     * Called with the sessionId when starting a new chat (no existing sessionId)
-     * Useful for updating external state like session lists
+     * Skill operations (list, get, execute, update)
      */
-    onSessionCreated?: (sessionId: string) => void;
-    /** @deprecated Use onSessionCreated instead */
-    onSessionStart?: (sessionId: string) => void;
-    /** Callback fired when a tool is called */
-    onToolCall?: (toolName: string, args: unknown) => void;
-    /** Callback fired when clarification is needed */
-    onClarification?: (data: ClarificationData) => void;
-    /** Initial messages to populate the chat */
-    initialMessages?: ChatMessage$1[];
-    /** Placeholder text for the input */
-    placeholder?: string;
-    /** Welcome message shown when chat is empty */
-    welcomeMessage?: string;
-    /** Maximum height of the chat container */
-    maxHeight?: string | number;
-    /** Additional CSS class for the container */
-    className?: string;
-    /** Theme mode */
-    theme?: ThemeMode;
-    /** Enable file attachments (future feature) */
-    enableAttachments?: boolean;
-    /** Enable markdown rendering */
-    enableMarkdown?: boolean;
-    /** Show tool call visualization */
-    showToolCalls?: boolean;
+    readonly skills: SkillsAPI;
+    /**
+     * Tool operations (list, get, execute, validate, update)
+     */
+    readonly tools: ToolsAPI;
+    /**
+     * Artifact operations (list, get, download, upload, delete)
+     */
+    readonly artifacts: ArtifactsAPI;
+    /**
+     * Session operations (list, get, create, message, delete)
+     */
+    readonly sessions: SessionsAPI;
+    /**
+     * Create a new AI SaaS client
+     *
+     * @param options - Client configuration options
+     *
+     * @example
+     * ```typescript
+     * // API key authentication
+     * const client = new AISaaSClient({
+     *   apiKey: 'sk_...',
+     *   orgId: 123,
+     * });
+     *
+     * // OAuth token authentication
+     * const client = new AISaaSClient({
+     *   token: 'eyJ...',
+     *   orgId: 123,
+     * });
+     *
+     * // Token provider (for automatic refresh)
+     * const client = new AISaaSClient({
+     *   tokenProvider: async () => myAuth.getAccessToken(),
+     *   orgId: 123,
+     * });
+     * ```
+     */
+    constructor(options: AISaaSClientOptions);
+    /**
+     * Validate client options
+     */
+    private validateOptions;
 }
-/**
- * Complete chat interface for interacting with AI agents
- *
- * @example
- * ```tsx
- * // With ChatConfigProvider (recommended for API key users)
- * <ChatConfigProvider config={{ baseUrl: '...', apiKey: '...' }}>
- *   <AgentChat
- *     agentId="agent-uuid"
- *     onMessage={(msg) => console.log('New message:', msg)}
- *   />
- * </ChatConfigProvider>
- *
- * // With custom adapter
- * <AgentChat
- *   agentId="agent-uuid"
- *   adapter={myCustomAdapter}
- * />
- * ```
- */
-declare function AgentChat({ agentId, sessionId, adapter, onMessage, onError, onSessionCreated, onSessionStart, onToolCall, onClarification, initialMessages, placeholder, welcomeMessage, maxHeight, className, theme, enableAttachments, enableMarkdown, showToolCalls, }: AgentChatProps): react_jsx_runtime.JSX.Element;
 
 /**
- * Default HTTP adapter for ChatAdapter
+ * Default adapter for ChatAdapter — thin wrapper around AISaaSClient
  *
- * Uses the AI SaaS External API for all operations.
+ * Uses the AISaaSClient for all operations, providing proper auth,
+ * retries, and streaming support out of the box.
  *
  * @module @cadraos/sdk/chat
  */
@@ -502,37 +2675,49 @@ declare function AgentChat({ agentId, sessionId, adapter, onMessage, onError, on
  * Configuration for the default HTTP adapter
  */
 interface DefaultAdapterConfig {
+    /**
+     * Pre-constructed AISaaSClient (takes priority over individual options)
+     */
+    client?: AISaaSClient;
     /**
      * Base URL for the API
-     * @example "https://api.example.com/api/v1/external"
+     * @example "https://api.example.com/v1"
      */
-    baseUrl: string;
+    baseUrl?: string;
     /**
      * API key for authentication
      */
     apiKey?: string;
     /**
-     * Organization ID for multi-tenant access
+     * OAuth token for authentication
      */
-    orgId?: number;
+    token?: string;
     /**
-     * Custom fetch function (for testing or custom HTTP clients)
+     * Token provider callback for dynamic auth
      */
-    fetch?: typeof fetch;
+    tokenProvider?: () => Promise<string>;
+    /**
+     * Organization ID for multi-tenant access
+     */
+    orgId?: number;
 }
 /**
- * Create a default HTTP adapter for the Chat component
+ * Create a default adapter that wraps AISaaSClient
  *
  * @param config - Adapter configuration
- * @returns ChatAdapter implementation
+ * @returns ChatAdapter implementation backed by AISaaSClient
  *
  * @example
  * ```typescript
+ * // With individual options
  * const adapter = createDefaultAdapter({
- *   baseUrl: 'https://api.example.com/api/v1/external',
+ *   baseUrl: 'https://api.example.com/v1',
  *   apiKey: 'your-api-key',
  *   orgId: 123,
  * });
+ *
+ * // With pre-constructed client
+ * const adapter = createDefaultAdapter({ client: myClient });
  * ```
  */
 declare function createDefaultAdapter(config: DefaultAdapterConfig): ChatAdapter;
@@ -549,7 +2734,7 @@ interface ChatConfigProviderProps {
     /**
      * Child components
      */
-    children: React.ReactNode;
+    children: React$1.ReactNode;
 }
 /**
  * Provider component that configures the default adapter for all child AgentChat components
@@ -587,8 +2772,13 @@ declare function useChatConfig(): ChatConfigContextValue;
 declare function useChatConfigOptional(): ChatConfigContextValue | null;
 
 interface UseAgentChatOptions {
-    /** UUID of the agent to chat with */
-    agentId: string;
+    /**
+     * UUID of the agent to chat with.
+     * Optional when teamId is provided (team execution routes to team's lead orchestrator).
+     */
+    agentId?: string;
+    /** Optional team UUID for team-based execution (routes to team's lead orchestrator) */
+    teamId?: string;
     /**
      * Session ID to resume an existing conversation
      * If provided, the hook will attempt to load the session history on mount
@@ -612,6 +2802,8 @@ interface UseAgentChatOptions {
     onSessionStart?: (sessionId: string) => void;
     /** Callback fired when a tool is called */
     onToolCall?: (toolName: string, args: unknown) => void;
+    /** Callback fired when a tool result is received */
+    onToolResult?: (toolName: string, result: unknown, durationMs?: number) => void;
     /** Callback fired when clarification is needed */
     onClarification?: (data: ClarificationData) => void;
 }
@@ -649,6 +2841,27 @@ interface UseAgentChatResult {
      */
     loadSession: (sessionId: string) => Promise<void>;
 }
+/**
+ * Main hook for managing chat state and interactions
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   messages,
+ *   isLoading,
+ *   isStreaming,
+ *   sendMessage,
+ *   error,
+ * } = useAgentChat({
+ *   agentId: 'agent-uuid',
+ *   adapter: myAdapter,
+ *   onMessage: (msg) => console.log('New message:', msg),
+ * });
+ *
+ * // Send a message
+ * await sendMessage('Hello, agent!');
+ * ```
+ */
 declare function useAgentChat(options: UseAgentChatOptions): UseAgentChatResult;
 
 interface UseExecutionStreamOptions {
@@ -700,6 +2913,11 @@ interface UseExecutionStreamResult {
 /**
  * Hook for streaming agent execution events via SSE
  *
+ * @deprecated Prefer using `adapter.createStream()` which provides
+ * fetch-based SSE with auth headers, automatic reconnection, and
+ * polling fallback. This hook is kept for backward compatibility
+ * with adapters that only implement `getStreamUrl`.
+ *
  * @example
  * ```typescript
  * const { isConnected, disconnect } = useExecutionStream({
@@ -714,7 +2932,7 @@ declare function useExecutionStream(options: UseExecutionStreamOptions): UseExec
 
 interface ChatContainerProps {
     /** Child components (MessageList, ChatInput, etc.) */
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     /** Maximum height of the container */
     maxHeight?: string | number;
     /** Additional CSS classes */
@@ -767,86 +2985,6 @@ interface ChatInputProps {
  */
 declare function ChatInput({ onSend, onStop, placeholder, disabled, isLoading, enableAttachments, className, }: ChatInputProps): react_jsx_runtime.JSX.Element;
 
-interface MessageListProps {
-    /** Array of messages to display */
-    messages: ChatMessage$1[];
-    /** Welcome message shown when chat is empty */
-    welcomeMessage?: string;
-    /** Whether a new message is loading */
-    isLoading?: boolean;
-    /** Whether the assistant is currently streaming a response */
-    isStreaming?: boolean;
-    /** Whether session history is being loaded */
-    isLoadingHistory?: boolean;
-    /** Whether to enable markdown rendering */
-    enableMarkdown?: boolean;
-    /** Whether to show tool calls */
-    showToolCalls?: boolean;
-    /** Additional CSS classes */
-    className?: string;
-}
-/**
- * Renders a scrollable list of chat messages with auto-scroll
- *
- * @example
- * ```tsx
- * <MessageList
- *   messages={messages}
- *   welcomeMessage="Hello! How can I help you today?"
- *   isLoading={isLoading}
- *   isStreaming={isStreaming}
- *   enableMarkdown
- *   showToolCalls
- * />
- * ```
- */
-declare function MessageList({ messages, welcomeMessage, isLoading, isStreaming, isLoadingHistory, enableMarkdown, showToolCalls, className, }: MessageListProps): react_jsx_runtime.JSX.Element;
-
-interface ChatMessageProps {
-    /** Message data */
-    message: ChatMessage$1;
-    /** Whether to enable markdown rendering */
-    enableMarkdown?: boolean;
-    /** Whether to show tool calls */
-    showToolCalls?: boolean;
-    /** Additional CSS classes */
-    className?: string;
-}
-/**
- * Renders a single chat message with appropriate styling
- *
- * @example
- * ```tsx
- * <ChatMessage
- *   message={{
- *     id: "1",
- *     role: "assistant",
- *     content: "Hello! How can I help?",
- *     timestamp: new Date(),
- *   }}
- *   enableMarkdown
- *   showToolCalls
- * />
- * ```
- */
-declare function ChatMessage({ message, enableMarkdown, showToolCalls, className, }: ChatMessageProps): react_jsx_runtime.JSX.Element;
-
-interface MarkdownContentProps {
-    /** Markdown content to render */
-    content: string;
-    /** Additional CSS classes */
-    className?: string;
-}
-/**
- * Renders markdown content with chat-appropriate styling
- *
- * @example
- * ```tsx
- * <MarkdownContent content="# Hello\n\nThis is **bold** text." />
- * ```
- */
-declare function MarkdownContent({ content, className }: MarkdownContentProps): react_jsx_runtime.JSX.Element;
-
 interface ToolCallEntryProps {
     /** Tool call data */
     toolCall: ToolCall;
@@ -854,6 +2992,12 @@ interface ToolCallEntryProps {
     className?: string;
     /** Whether to show the full JSON in expanded view */
     showFullJson?: boolean;
+    /** Optional callback when an image is clicked. If provided, overrides default browser-open behavior. */
+    onImageClick?: (image: {
+        url: string;
+        alt?: string;
+        filename?: string;
+    }) => void;
 }
 /**
  * Displays a single tool call with status and expandable details
@@ -872,7 +3016,7 @@ interface ToolCallEntryProps {
  * />
  * ```
  */
-declare function ToolCallEntry({ toolCall, className, showFullJson, }: ToolCallEntryProps): react_jsx_runtime.JSX.Element;
+declare function ToolCallEntry({ toolCall, className, showFullJson, onImageClick, }: ToolCallEntryProps): react_jsx_runtime.JSX.Element;
 
 interface AskUserPromptProps {
     /** The question to display to the user */
@@ -971,4 +3115,4 @@ declare function HelpCircleIcon({ className, ...props }: IconProps): react_jsx_r
 declare function DatabaseIcon({ className, ...props }: IconProps): react_jsx_runtime.JSX.Element;
 declare function ClockIcon({ className, ...props }: IconProps): react_jsx_runtime.JSX.Element;
 
-export { AgentChat, type AgentChatProps, AlertCircleIcon, type Artifact, AskUserPrompt, type AskUserPromptProps, type AttachmentData, type AttachmentFile, BotIcon, type ChatAdapter, ChatConfigProvider, type ChatConfigProviderProps, ChatContainer, type ChatContainerProps, type ChatError, ChatInput, type ChatInputProps, ChatMessage, type ChatMessageProps, type ChatMessage$1 as ChatMessageType, CheckCircleIcon, CheckIcon, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, CircleIcon, type ClarificationData, ClockIcon, CodeIcon, CopyIcon, DatabaseIcon, type DefaultAdapterConfig, DownloadIcon, type Execution, type ExecutionResult, type ExecutionStreamEvent, ExternalLinkIcon, FileIcon, FileTextIcon, HelpCircleIcon, type HistoryMessage, type IconProps, ImageIcon, ImagesIcon, ListTodoIcon, LoadingSpinner, MarkdownContent, type MarkdownContentProps, Maximize2Icon, MessageCircleIcon, MessageList, type MessageListProps, Minimize2Icon, PaperclipIcon, SendIcon, type SendMessageInput, type SessionHistory, SparklesIcon, type StartExecutionInput, StopCircleIcon, type ThemeMode, type ThinkingBlock, type TodoItem, TodoList, type TodoListProps, type ToolCall, ToolCallEntry, type ToolCallEntryProps, type UploadUrlInput, type UploadUrlResult, type UseAgentChatOptions, type UseAgentChatResult, type UseExecutionStreamOptions, type UseExecutionStreamResult, UserIcon, XIcon, ZoomInIcon, ZoomOutIcon, createDefaultAdapter, useAgentChat, useChatConfig, useChatConfigOptional, useExecutionStream };
+export { AgentChat, type AgentChatProps, AlertCircleIcon, type Artifact$1 as Artifact, AskUserPrompt, type AskUserPromptProps, type AttachmentData, type AttachmentFile, BotIcon, type ChatAdapter, ChatConfigProvider, type ChatConfigProviderProps, ChatContainer, type ChatContainerProps, type ChatError, ChatInput, type ChatInputProps, ChatMessage, type ChatMessageProps, type ChatMessage$1 as ChatMessageType, CheckCircleIcon, CheckIcon, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, CircleIcon, type ClarificationData, ClockIcon, CodeIcon, CopyIcon, DatabaseIcon, type DefaultAdapterConfig, DownloadIcon, type Execution, type ExecutionResult, type ExecutionStreamEvent, ExternalLinkIcon, FileIcon, FileTextIcon, HelpCircleIcon, type HistoryMessage, type IconProps, ImageIcon, ImagesIcon, type ListSessionsInput, ListTodoIcon, LoadingSpinner, MarkdownContent, type MarkdownContentProps, Maximize2Icon, MessageCircleIcon, MessageList, type MessageListProps, Minimize2Icon, PaperclipIcon, SendIcon, type SendMessageInput$1 as SendMessageInput, type SessionHistory$1 as SessionHistory, type SessionList, type SessionListItem, SparklesIcon, type StartExecutionInput, StopCircleIcon, type ThemeMode, type ThinkingBlock, type TodoItem, TodoList, type TodoListProps, type ToolCall, ToolCallEntry, type ToolCallEntryProps, type UploadUrlInput, type UploadUrlResult, type UseAgentChatOptions, type UseAgentChatResult, type UseExecutionStreamOptions, type UseExecutionStreamResult, UserIcon, XIcon, ZoomInIcon, ZoomOutIcon, createDefaultAdapter, useAgentChat, useChatConfig, useChatConfigOptional, useExecutionStream };