@yourgpt/copilot-sdk 0.1.0

package/dist/react/index.d.ts

@@ -0,0 +1,1824 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default from 'react';
+import { M as MessageAttachment, A as ToolCall, f as Source, D as LLMConfig, T as ToolDefinition, af as PermissionLevel, i as ToolInputSchema, G as CopilotConfig, s as ToolsConfig, y as Message, O as ActionDefinition, v as CapturedContext, t as ToolConsentRequest, r as ToolType, aa as ToolExecution$1, u as ToolConsentResponse, S as ScreenshotOptions, C as ConsoleLogOptions, N as NetworkRequestOptions, I as IntentDetectionResult, k as ToolContext, h as ToolResponse$1, a4 as ToolRenderProps, a6 as ToolSet, a7 as UnifiedToolCall, Y as InternalKnowledgeBaseConfig, _ as InternalKnowledgeBaseSearchResponse, Z as InternalKnowledgeBaseResult, ah as PermissionStorageConfig, ai as PermissionStorageAdapter } from '../thread-C2FjuGLb.js';
+export { K as ActionParameter, ab as AgentLoopConfig, E as CloudConfig, a1 as PersistenceConfig, $ as Thread, a0 as ThreadData, a2 as ThreadStorageAdapter, g as ToolExecutionStatus, ag as ToolPermission, o as generateSuggestionReason } from '../thread-C2FjuGLb.js';
+
+/**
+ * Message Types
+ *
+ * Pure type definitions for chat messages.
+ * No logic, no side effects - just types.
+ */
+
+/**
+ * Chat message roles
+ */
+type MessageRole = "user" | "assistant" | "system" | "tool";
+/**
+ * UIMessage - The source of truth for UI state
+ *
+ * Inspired by Vercel AI SDK's UIMessage pattern.
+ * This is what your UI renders and what gets persisted.
+ */
+interface UIMessage {
+    /** Unique message ID */
+    id: string;
+    /** Message role */
+    role: MessageRole;
+    /** Message content */
+    content: string;
+    /** Thinking/reasoning content (for extended thinking models) */
+    thinking?: string;
+    /** Message attachments (images, PDFs, etc) */
+    attachments?: MessageAttachment[];
+    /** Tool calls made by assistant */
+    toolCalls?: ToolCall[];
+    /** Tool call ID (for tool result messages) */
+    toolCallId?: string;
+    /** Sources from knowledge base */
+    sources?: Source[];
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * ChatTransport Interface
+ *
+ * Contract for different transport implementations.
+ * HTTP, WebSocket, or mock for testing.
+ */
+/**
+ * Chat request to send
+ */
+interface ChatRequest {
+    /** Messages to send */
+    messages: Array<{
+        role: string;
+        content: string | null;
+        tool_calls?: unknown[];
+        tool_call_id?: string;
+        attachments?: unknown[];
+    }>;
+    /** Thread ID */
+    threadId?: string;
+    /** System prompt */
+    systemPrompt?: string;
+    /** LLM config */
+    llm?: Record<string, unknown>;
+    /** Tool definitions */
+    tools?: unknown[];
+    /** Action definitions */
+    actions?: unknown[];
+    /** Additional body properties */
+    body?: Record<string, unknown>;
+}
+/**
+ * Chat response (non-streaming)
+ */
+interface ChatResponse {
+    /** Response messages */
+    messages: Array<{
+        role: string;
+        content: string | null;
+        tool_calls?: unknown[];
+    }>;
+    /** Whether client needs to execute tools */
+    requiresAction?: boolean;
+}
+/**
+ * Stream chunk types
+ */
+type StreamChunk = {
+    type: "message:start";
+    id: string;
+} | {
+    type: "message:delta";
+    content: string;
+} | {
+    type: "message:end";
+} | {
+    type: "thinking:delta";
+    content: string;
+} | {
+    type: "tool_calls";
+    toolCalls: unknown[];
+    assistantMessage: unknown;
+} | {
+    type: "source:add";
+    source: unknown;
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "done";
+    messages?: unknown[];
+    requiresAction?: boolean;
+};
+/**
+ * ChatTransport interface
+ *
+ * Allows different transport implementations:
+ * - HTTP (default) - uses fetch with SSE
+ * - WebSocket - for real-time connections
+ * - Mock - for testing
+ *
+ * @example
+ * ```typescript
+ * const transport = new HttpTransport({
+ *   url: '/api/chat',
+ *   headers: { ... }
+ * });
+ *
+ * const stream = await transport.send(request);
+ * for await (const chunk of stream) {
+ *   console.log(chunk);
+ * }
+ * ```
+ */
+interface ChatTransport {
+    /**
+     * Send a chat request
+     *
+     * @param request - The chat request
+     * @returns AsyncIterable of stream chunks, or ChatResponse for non-streaming
+     */
+    send(request: ChatRequest): Promise<AsyncIterable<StreamChunk> | ChatResponse>;
+    /**
+     * Abort the current request
+     */
+    abort(): void;
+    /**
+     * Check if currently streaming
+     */
+    isStreaming(): boolean;
+}
+
+/**
+ * ChatState Interface
+ *
+ * Contract for framework-specific state implementations.
+ * React, Vue, Svelte each implement this differently.
+ */
+
+/**
+ * ChatState interface - Framework adapters implement this
+ *
+ * This is the key abstraction that enables framework-agnostic code.
+ * The AbstractChat class uses this interface, and each framework
+ * provides its own implementation.
+ *
+ * @example React implementation
+ * ```typescript
+ * class ReactChatState implements ChatState<UIMessage> {
+ *   #messages: UIMessage[] = [];
+ *   #callbacks = new Set<() => void>();
+ *
+ *   get messages() { return this.#messages; }
+ *   set messages(m) {
+ *     this.#messages = m;
+ *     this.#callbacks.forEach(cb => cb()); // Trigger re-render
+ *   }
+ *
+ *   subscribe(cb: () => void) {
+ *     this.#callbacks.add(cb);
+ *     return () => this.#callbacks.delete(cb);
+ *   }
+ * }
+ * ```
+ *
+ * @example Vue implementation
+ * ```typescript
+ * class VueChatState implements ChatState<UIMessage> {
+ *   messages = ref<UIMessage[]>([]);
+ *   status = ref<ChatStatus>('ready');
+ *   // Vue refs are automatically reactive
+ * }
+ * ```
+ */
+interface ChatState$1<T extends UIMessage = UIMessage> {
+    /** All messages in the conversation */
+    messages: T[];
+    /** Current chat status */
+    status: ChatStatus$1;
+    /** Current error if any */
+    error: Error | undefined;
+    /**
+     * Add a message to the end
+     */
+    pushMessage(message: T): void;
+    /**
+     * Remove the last message
+     */
+    popMessage(): void;
+    /**
+     * Replace a message at index
+     */
+    replaceMessage(index: number, message: T): void;
+    /**
+     * Update the last message (common during streaming)
+     */
+    updateLastMessage(updater: (message: T) => T): void;
+    /**
+     * Set all messages (replace entire array)
+     */
+    setMessages(messages: T[]): void;
+    /**
+     * Clear all messages
+     */
+    clearMessages(): void;
+    /**
+     * Subscribe to state changes
+     * Returns unsubscribe function
+     *
+     * This is used by React's useSyncExternalStore.
+     * Vue/Svelte may not need this (they use refs/stores).
+     */
+    subscribe?(callback: () => void): () => void;
+    /**
+     * Get immutable snapshot of messages
+     * Used by useSyncExternalStore's getSnapshot
+     */
+    getMessagesSnapshot?(): T[];
+    /**
+     * Get status snapshot
+     */
+    getStatusSnapshot?(): ChatStatus$1;
+    /**
+     * Get error snapshot
+     */
+    getErrorSnapshot?(): Error | undefined;
+}
+
+/**
+ * Chat status
+ */
+type ChatStatus$1 = "ready" | "submitted" | "streaming" | "error";
+/**
+ * Chat configuration
+ */
+interface ChatConfig {
+    /** Runtime API endpoint */
+    runtimeUrl: string;
+    /** LLM configuration */
+    llm?: Partial<LLMConfig>;
+    /** System prompt */
+    systemPrompt?: string;
+    /** Enable streaming (default: true) */
+    streaming?: boolean;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Thread ID for conversation persistence */
+    threadId?: string;
+    /** Debug mode */
+    debug?: boolean;
+    /** Available tools (passed to LLM) */
+    tools?: ToolDefinition[];
+}
+/**
+ * Chat callbacks for state updates
+ */
+interface ChatCallbacks<T extends UIMessage = UIMessage> {
+    /** Called when messages change */
+    onMessagesChange?: (messages: T[]) => void;
+    /** Called when status changes */
+    onStatusChange?: (status: ChatStatus$1) => void;
+    /** Called when an error occurs */
+    onError?: (error: Error | null) => void;
+    /** Called when a message starts streaming */
+    onMessageStart?: (messageId: string) => void;
+    /** Called when message content is streamed */
+    onMessageDelta?: (messageId: string, delta: string) => void;
+    /** Called when a message finishes */
+    onMessageFinish?: (message: T) => void;
+    /** Called when tool calls are received */
+    onToolCalls?: (toolCalls: T["toolCalls"]) => void;
+    /** Called when generation is complete */
+    onFinish?: (messages: T[]) => void;
+}
+/**
+ * Chat initialization options
+ */
+interface ChatInit<T extends UIMessage = UIMessage> extends ChatConfig {
+    /** Initial messages */
+    initialMessages?: T[];
+    /** State implementation (injected by framework adapter) */
+    state?: ChatState$1<T>;
+    /** Transport implementation */
+    transport?: ChatTransport;
+    /** Callbacks */
+    callbacks?: ChatCallbacks<T>;
+}
+
+/**
+ * Tool Types
+ *
+ * Types for tool execution and agent loop.
+ */
+
+/**
+ * Tool execution status
+ */
+type ToolExecutionStatus = "pending" | "executing" | "completed" | "failed" | "rejected";
+/**
+ * Tool approval status
+ */
+type ToolApprovalStatus = "none" | "required" | "approved" | "rejected";
+/**
+ * Tool execution record
+ */
+interface ToolExecution {
+    id: string;
+    toolCallId: string;
+    name: string;
+    args: Record<string, unknown>;
+    status: ToolExecutionStatus;
+    approvalStatus: ToolApprovalStatus;
+    result?: unknown;
+    error?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+/**
+ * Tool response
+ */
+interface ToolResponse {
+    toolCallId: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Agent loop configuration
+ */
+interface AgentLoopConfig {
+    /** Maximum iterations */
+    maxIterations?: number;
+    /** Auto-approve all tools */
+    autoApprove?: boolean;
+    /** Initial tools */
+    tools?: ToolDefinition[];
+    /** Max tool executions to keep in memory (default: 100). Oldest are pruned. */
+    maxExecutionHistory?: number;
+}
+/**
+ * Agent loop callbacks
+ */
+interface AgentLoopCallbacks {
+    /** Called when tool executions change */
+    onExecutionsChange?: (executions: ToolExecution[]) => void;
+    /** Called when a tool needs approval */
+    onApprovalRequired?: (execution: ToolExecution) => void;
+    /** Called when a tool starts */
+    onToolStart?: (execution: ToolExecution) => void;
+    /** Called when a tool completes */
+    onToolComplete?: (execution: ToolExecution) => void;
+    /** Called to continue chat with tool results */
+    onContinue?: (results: ToolResponse[]) => Promise<void>;
+    /** Called when max iterations reached */
+    onMaxIterationsReached?: () => void;
+}
+/**
+ * Agent loop state
+ */
+interface AgentLoopState$1 {
+    toolExecutions: ToolExecution[];
+    iteration: number;
+    maxIterations: number;
+    maxIterationsReached: boolean;
+    isProcessing: boolean;
+}
+/**
+ * Agent loop actions interface
+ */
+interface AgentLoopActions {
+    approveToolExecution: (executionId: string, permissionLevel?: PermissionLevel) => void;
+    rejectToolExecution: (executionId: string, reason?: string, permissionLevel?: PermissionLevel) => void;
+    clearToolExecutions: () => void;
+}
+/**
+ * Initial agent loop state
+ */
+declare const initialAgentLoopState: AgentLoopState$1;
+
+/**
+ * Event types emitted by AbstractChat
+ */
+type ChatEvent = {
+    type: "toolCalls";
+    toolCalls: UIMessage["toolCalls"];
+} | {
+    type: "done";
+} | {
+    type: "error";
+    error: Error;
+};
+/**
+ * Event handler type
+ */
+type ChatEventHandler<T extends ChatEvent["type"]> = (event: Extract<ChatEvent, {
+    type: T;
+}>) => void;
+/**
+ * AbstractChat - Core chat functionality
+ *
+ * @example
+ * ```typescript
+ * // With React state
+ * class ReactChat extends AbstractChat {
+ *   constructor(config: ChatInit) {
+ *     const state = new ReactChatState();
+ *     super({ ...config, state });
+ *   }
+ * }
+ *
+ * // Usage
+ * const chat = new ReactChat({ runtimeUrl: '/api/chat' });
+ * await chat.sendMessage('Hello!');
+ * ```
+ */
+declare class AbstractChat<T extends UIMessage = UIMessage> {
+    protected state: ChatState$1<T>;
+    protected transport: ChatTransport;
+    protected config: ChatConfig;
+    protected callbacks: ChatCallbacks<T>;
+    private eventHandlers;
+    private streamState;
+    constructor(init: ChatInit<T>);
+    get messages(): T[];
+    get status(): ChatStatus$1;
+    get error(): Error | undefined;
+    get isStreaming(): boolean;
+    /**
+     * Send a message
+     */
+    sendMessage(content: string, attachments?: MessageAttachment[]): Promise<void>;
+    /**
+     * Continue with tool results
+     *
+     * Automatically handles `addAsUserMessage` flag in results (e.g., screenshots).
+     * When a tool result has this flag, the attachment is extracted and sent as
+     * a user message so the AI can see it (e.g., for vision analysis).
+     */
+    continueWithToolResults(toolResults: Array<{
+        toolCallId: string;
+        result: unknown;
+    }>): Promise<void>;
+    /**
+     * Stop generation
+     */
+    stop(): void;
+    /**
+     * Clear all messages
+     */
+    clearMessages(): void;
+    /**
+     * Set messages directly
+     */
+    setMessages(messages: T[]): void;
+    /**
+     * Regenerate last response
+     */
+    regenerate(messageId?: string): Promise<void>;
+    /**
+     * Subscribe to events
+     */
+    on<E extends ChatEvent["type"]>(event: E, handler: ChatEventHandler<E>): () => void;
+    /**
+     * Emit an event
+     */
+    protected emit<E extends ChatEvent["type"]>(type: E, data: Omit<Extract<ChatEvent, {
+        type: E;
+    }>, "type">): void;
+    /**
+     * Process a chat request
+     */
+    protected processRequest(): Promise<void>;
+    /**
+     * Set tools available for the LLM
+     */
+    setTools(tools: ToolDefinition[]): void;
+    /**
+     * Dynamic context from useAIContext hook
+     */
+    protected dynamicContext: string;
+    /**
+     * Set dynamic context (appended to system prompt)
+     */
+    setContext(context: string): void;
+    /**
+     * Build the request payload
+     */
+    protected buildRequest(): {
+        messages: ({
+            role: "tool";
+            content: string;
+            tool_call_id: string;
+            tool_calls?: undefined;
+            attachments?: undefined;
+        } | {
+            role: MessageRole;
+            content: string;
+            tool_calls: ToolCall[] | undefined;
+            tool_call_id: string | undefined;
+            attachments: MessageAttachment[] | undefined;
+        })[];
+        threadId: string | undefined;
+        systemPrompt: string | undefined;
+        llm: Partial<LLMConfig> | undefined;
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: ToolInputSchema;
+        }[] | undefined;
+    };
+    /**
+     * Handle streaming response
+     */
+    protected handleStreamResponse(stream: AsyncIterable<StreamChunk>): Promise<void>;
+    /**
+     * Handle JSON (non-streaming) response
+     */
+    protected handleJsonResponse(response: ChatResponse): void;
+    /**
+     * Handle errors
+     */
+    protected handleError(error: Error): void;
+    /**
+     * Debug logging
+     */
+    protected debug(action: string, data?: unknown): void;
+    /**
+     * Type guard for async iterable
+     */
+    private isAsyncIterable;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+
+/**
+ * AbstractAgentLoop - Framework-agnostic agent loop for tool execution
+ *
+ * Handles the agentic loop where the LLM can call tools, receive results,
+ * and continue processing until completion.
+ */
+
+/**
+ * Tool call info from LLM response
+ */
+interface ToolCallInfo {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * AbstractAgentLoop - Core agent loop functionality
+ *
+ * @example
+ * ```typescript
+ * const agentLoop = new AbstractAgentLoop(config, {
+ *   onToolExecutionsChange: setToolExecutions,
+ *   onToolApprovalRequired: handleApproval,
+ * });
+ *
+ * // Register tools
+ * agentLoop.registerTool(myTool);
+ *
+ * // Execute tool calls from LLM
+ * await agentLoop.executeToolCalls(toolCalls);
+ * ```
+ */
+declare class AbstractAgentLoop implements AgentLoopActions {
+    private _toolExecutions;
+    private _iteration;
+    private _maxIterations;
+    private _maxIterationsReached;
+    private _isProcessing;
+    private registeredTools;
+    private pendingApprovals;
+    private config;
+    private callbacks;
+    private _maxExecutionHistory;
+    constructor(config?: AgentLoopConfig, callbacks?: AgentLoopCallbacks);
+    get toolExecutions(): ToolExecution[];
+    get iteration(): number;
+    get maxIterations(): number;
+    get maxIterationsReached(): boolean;
+    get isProcessing(): boolean;
+    get state(): AgentLoopState$1;
+    get pendingApprovalExecutions(): ToolExecution[];
+    get tools(): ToolDefinition[];
+    private setToolExecutions;
+    private setIteration;
+    private setProcessing;
+    private addToolExecution;
+    private updateToolExecution;
+    /**
+     * Register a tool
+     */
+    registerTool(tool: ToolDefinition): void;
+    /**
+     * Unregister a tool
+     */
+    unregisterTool(name: string): void;
+    /**
+     * Get a registered tool
+     */
+    getTool(name: string): ToolDefinition | undefined;
+    /**
+     * Execute tool calls from LLM response
+     * Returns tool results for sending back to LLM
+     */
+    executeToolCalls(toolCalls: ToolCallInfo[]): Promise<ToolResponse[]>;
+    /**
+     * Execute a single tool
+     */
+    private executeSingleTool;
+    /**
+     * Wait for user approval
+     */
+    private waitForApproval;
+    /**
+     * Approve a tool execution
+     */
+    approveToolExecution(executionId: string, _permissionLevel?: PermissionLevel): void;
+    /**
+     * Reject a tool execution
+     */
+    rejectToolExecution(executionId: string, reason?: string, _permissionLevel?: PermissionLevel): void;
+    /**
+     * Clear all tool executions
+     */
+    clearToolExecutions(): void;
+    /**
+     * Reset the agent loop for a new conversation
+     */
+    reset(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<AgentLoopConfig>): void;
+    /**
+     * Update callbacks
+     */
+    updateCallbacks(callbacks: Partial<AgentLoopCallbacks>): void;
+    /**
+     * Dispose of resources
+     */
+    dispose(): void;
+}
+
+interface CopilotProviderProps {
+    children: React__default.ReactNode;
+    runtimeUrl: string;
+    config?: CopilotConfig["config"];
+    cloud?: CopilotConfig["cloud"];
+    systemPrompt?: string;
+    /** @deprecated Use useTools() hook instead */
+    tools?: ToolsConfig;
+    threadId?: string;
+    initialMessages?: Message[];
+    onMessagesChange?: (messages: Message[]) => void;
+    onError?: (error: Error) => void;
+    /** Enable/disable streaming (default: true) */
+    streaming?: boolean;
+    debug?: boolean;
+}
+interface CopilotContextValue {
+    messages: UIMessage[];
+    status: "ready" | "submitted" | "streaming" | "error";
+    error: Error | null;
+    isLoading: boolean;
+    sendMessage: (content: string, attachments?: MessageAttachment[]) => Promise<void>;
+    stop: () => void;
+    clearMessages: () => void;
+    regenerate: (messageId?: string) => Promise<void>;
+    registerTool: (tool: ToolDefinition) => void;
+    unregisterTool: (name: string) => void;
+    registeredTools: ToolDefinition[];
+    toolExecutions: ToolExecution[];
+    pendingApprovals: ToolExecution[];
+    approveToolExecution: (id: string, permissionLevel?: PermissionLevel) => void;
+    rejectToolExecution: (id: string, reason?: string, permissionLevel?: PermissionLevel) => void;
+    registerAction: (action: ActionDefinition) => void;
+    unregisterAction: (name: string) => void;
+    registeredActions: ActionDefinition[];
+    addContext: (context: string, parentId?: string) => string;
+    removeContext: (id: string) => void;
+    threadId?: string;
+    runtimeUrl: string;
+    toolsConfig?: ToolsConfig;
+}
+declare function useCopilot(): CopilotContextValue;
+declare function CopilotProvider({ children, runtimeUrl, config, cloud, systemPrompt, tools: toolsConfig, threadId, initialMessages, onMessagesChange, onError, streaming, debug, }: CopilotProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Chat UI state interface (UI-only state, not message data)
+ * Message data is stored in ThreadsState as the single source of truth
+ */
+interface ChatState {
+    /** Whether a response is being generated */
+    isLoading: boolean;
+    /** Current error if any */
+    error: Error | null;
+}
+/**
+ * Combined chat state for context consumers
+ * Includes derived data from threads for convenience
+ */
+interface CombinedChatState {
+    /** All messages in the conversation (from active thread) */
+    messages: Message[];
+    /** Whether a response is being generated */
+    isLoading: boolean;
+    /** Current error if any */
+    error: Error | null;
+    /** Thread/conversation ID (from active thread) */
+    threadId: string | null;
+    /** Sources from knowledge base (from active thread) */
+    sources: Source[];
+}
+/**
+ * Tools state interface (Smart Context tools)
+ */
+interface ToolsState {
+    /** Whether tools are enabled */
+    isEnabled: boolean;
+    /** Pending consent request */
+    pendingConsent: ToolConsentRequest | null;
+    /** Last captured context */
+    lastContext: CapturedContext | null;
+    /** Currently capturing */
+    isCapturing: boolean;
+}
+/**
+ * Agent loop state interface (Agentic tools)
+ */
+interface AgentLoopState {
+    /** Current tool executions */
+    toolExecutions: ToolExecution$1[];
+    /** Current loop iteration */
+    iteration: number;
+    /** Maximum iterations */
+    maxIterations: number;
+    /** Whether max iterations was reached */
+    maxIterationsReached: boolean;
+    /** Whether waiting for server response after tool completion */
+    isProcessing: boolean;
+}
+/**
+ * Chat actions interface
+ */
+interface ChatActions {
+    /** Send a message (with optional attachments) */
+    sendMessage: (content: string, attachments?: MessageAttachment[]) => Promise<void>;
+    /** Send a message with context */
+    sendMessageWithContext: (content: string, context: CapturedContext) => Promise<void>;
+    /** Stop generation */
+    stopGeneration: () => void;
+    /** Clear all messages */
+    clearMessages: () => void;
+    /** Regenerate last response */
+    regenerate: (messageId?: string) => Promise<void>;
+    /** Set messages directly */
+    setMessages: (messages: Message[]) => void;
+    /**
+     * Process file to MessageAttachment
+     * - Premium: uploads to cloud storage, returns URL-based attachment
+     * - Free: converts to base64
+     */
+    processAttachment: (file: File) => Promise<MessageAttachment>;
+}
+/**
+ * Tools actions interface
+ */
+interface ToolsActions {
+    /** Request consent for tools */
+    requestConsent: (tools: ToolType[], reason?: string) => void;
+    /** Respond to consent request */
+    respondToConsent: (approved: ToolType[], remember?: boolean) => void;
+    /** Capture context */
+    captureContext: (tools: ToolType[]) => Promise<CapturedContext>;
+    /** Clear pending consent */
+    clearConsent: () => void;
+}
+
+/**
+ * Hook to register multiple AI actions/tools
+ *
+ * @example
+ * ```tsx
+ * useAIActions([
+ *   {
+ *     name: 'getWeather',
+ *     description: 'Get weather for a location',
+ *     parameters: {
+ *       location: { type: 'string', required: true, description: 'City name' },
+ *     },
+ *     handler: async ({ location }) => {
+ *       const weather = await fetchWeather(location);
+ *       return weather;
+ *     },
+ *   },
+ * ]);
+ * ```
+ */
+declare function useAIActions(actions: ActionDefinition[]): void;
+/**
+ * Hook to register a single AI action/tool
+ *
+ * @example
+ * ```tsx
+ * useAIAction({
+ *   name: 'searchProducts',
+ *   description: 'Search for products',
+ *   parameters: {
+ *     query: { type: 'string', required: true },
+ *   },
+ *   handler: async ({ query }) => {
+ *     return await searchProducts(query);
+ *   },
+ * });
+ * ```
+ */
+declare function useAIAction(action: ActionDefinition): void;
+
+/**
+ * Context item for AI
+ */
+interface AIContextItem {
+    /** Unique key for this context */
+    key: string;
+    /** Data to provide to AI (will be JSON stringified) */
+    data: unknown;
+    /** Optional description to help AI understand the context */
+    description?: string;
+    /** Parent context ID for hierarchical/nested contexts */
+    parentId?: string;
+}
+/**
+ * Hook to provide app state/context to the AI
+ *
+ * This hook allows you to inject React state into the AI's context,
+ * so it can understand and reference your app's current state.
+ *
+ * @returns Context ID that can be used as `parentId` for nested contexts
+ *
+ * @example Basic usage
+ * ```tsx
+ * function CartPage() {
+ *   const [cart, setCart] = useState([]);
+ *
+ *   // Provide cart data to AI
+ *   useAIContext({
+ *     key: 'cart',
+ *     data: cart,
+ *     description: 'User shopping cart items',
+ *   });
+ *
+ *   return <CartUI cart={cart} />;
+ * }
+ * ```
+ *
+ * @example Nested/hierarchical contexts
+ * ```tsx
+ * function EmployeeList({ employees }) {
+ *   // Parent context - returns ID for nesting
+ *   const listId = useAIContext({
+ *     key: 'employees',
+ *     data: { count: employees.length },
+ *     description: 'Employee list',
+ *   });
+ *
+ *   return employees.map(emp => (
+ *     <Employee key={emp.id} employee={emp} parentContextId={listId} />
+ *   ));
+ * }
+ *
+ * function Employee({ employee, parentContextId }) {
+ *   // Child context - nested under parent
+ *   useAIContext({
+ *     key: `employee-${employee.id}`,
+ *     data: employee,
+ *     description: employee.name,
+ *     parentId: parentContextId,  // Links to parent context
+ *   });
+ *
+ *   return <div>{employee.name}</div>;
+ * }
+ * ```
+ */
+declare function useAIContext(item: AIContextItem): string | undefined;
+/**
+ * Hook to provide multiple context items at once
+ *
+ * @example
+ * ```tsx
+ * useAIContexts([
+ *   { key: 'user', data: currentUser },
+ *   { key: 'cart', data: cartItems },
+ *   { key: 'page', data: { route: '/checkout', step: 2 } },
+ * ]);
+ * ```
+ */
+declare function useAIContexts(items: AIContextItem[]): void;
+
+/**
+ * useAITools options
+ */
+interface UseAIToolsOptions extends ToolsConfig {
+    /** Callback when consent is requested */
+    onConsentRequest?: (request: ToolConsentRequest) => Promise<ToolConsentResponse>;
+    /** Auto-start capturing when enabled */
+    autoStart?: boolean;
+}
+/**
+ * useAITools return type
+ */
+interface UseAIToolsReturn {
+    /** Whether tools are enabled */
+    isEnabled: boolean;
+    /** Currently active captures */
+    activeCaptures: {
+        console: boolean;
+        network: boolean;
+    };
+    /** Capture screenshot */
+    captureScreenshot: (options?: ScreenshotOptions) => Promise<CapturedContext["screenshot"]>;
+    /** Get console logs */
+    getConsoleLogs: (options?: ConsoleLogOptions) => CapturedContext["consoleLogs"];
+    /** Get network requests */
+    getNetworkRequests: (options?: NetworkRequestOptions) => CapturedContext["networkRequests"];
+    /** Capture all enabled context */
+    captureContext: (tools?: ToolType[]) => Promise<CapturedContext>;
+    /** Detect intent from message */
+    detectIntent: (message: string) => IntentDetectionResult;
+    /** Request consent for tools */
+    requestConsent: (tools: ToolType[], reason?: string) => Promise<ToolConsentResponse>;
+    /** Start capturing */
+    startCapturing: () => void;
+    /** Stop capturing */
+    stopCapturing: () => void;
+    /** Clear captured data */
+    clearCaptured: () => void;
+    /** Format captured context for AI */
+    formatForAI: (context: CapturedContext) => string;
+    /** Pending consent request (for UI) */
+    pendingConsent: ToolConsentRequest | null;
+    /** Respond to consent request */
+    respondToConsent: (response: ToolConsentResponse) => void;
+}
+/**
+ * Hook for AI Smart Context Tools
+ *
+ * Provides React integration for screenshot, console, and network capture
+ * with consent-based UX and intent detection.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   captureScreenshot,
+ *   getConsoleLogs,
+ *   detectIntent,
+ *   pendingConsent,
+ *   respondToConsent,
+ * } = useAITools({
+ *   screenshot: true,
+ *   console: true,
+ *   network: true,
+ *   requireConsent: true,
+ * });
+ *
+ * // Detect if tools are needed based on user message
+ * const handleMessage = async (message: string) => {
+ *   const intent = detectIntent(message);
+ *
+ *   if (intent.suggestedTools.length > 0) {
+ *     const consent = await requestConsent(
+ *       intent.suggestedTools,
+ *       generateSuggestionReason(intent)
+ *     );
+ *
+ *     if (consent.approved.length > 0) {
+ *       const context = await captureContext(consent.approved);
+ *       // Include context with message
+ *     }
+ *   }
+ * };
+ * ```
+ */
+declare function useAITools(options?: UseAIToolsOptions): UseAIToolsReturn;
+
+/**
+ * Configuration for registering a tool (legacy format)
+ */
+interface UseToolConfig<TParams = Record<string, unknown>> {
+    /** Unique tool name */
+    name: string;
+    /** Tool description for LLM */
+    description: string;
+    /** JSON Schema for input parameters */
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    /** Handler function */
+    handler: (params: TParams, context?: ToolContext) => Promise<ToolResponse$1> | ToolResponse$1;
+    /** Optional render function for UI */
+    render?: (props: ToolRenderProps<TParams>) => React.ReactNode;
+    /** Whether the tool is available */
+    available?: boolean;
+    /** Require user approval */
+    needsApproval?: boolean;
+    /** Custom approval message */
+    approvalMessage?: string;
+}
+/**
+ * Register a client-side tool
+ *
+ * This hook registers a tool that can be called by the AI during a conversation.
+ * The tool will execute on the client side.
+ *
+ * @example
+ * ```tsx
+ * useTool({
+ *   name: "navigate_to_page",
+ *   description: "Navigate to a specific page in the app",
+ *   inputSchema: {
+ *     type: "object",
+ *     properties: {
+ *       path: { type: "string", description: "The path to navigate to" },
+ *     },
+ *     required: ["path"],
+ *   },
+ *   handler: async ({ path }) => {
+ *     router.push(path);
+ *     return { success: true, message: `Navigated to ${path}` };
+ *   },
+ * });
+ * ```
+ */
+declare function useTool<TParams = Record<string, unknown>>(config: UseToolConfig<TParams>, dependencies?: unknown[]): void;
+/**
+ * Register multiple tools using a ToolSet (Vercel AI SDK pattern)
+ *
+ * This is the recommended way to register tools as it follows
+ * the Vercel AI SDK pattern with explicit tool definitions.
+ *
+ * @example
+ * ```tsx
+ * import { useTools } from '@yourgpt/copilot-sdk-react';
+ * import { builtinTools, tool, success } from '../core';
+ *
+ * function MyApp() {
+ *   // Register built-in tools
+ *   useTools({
+ *     capture_screenshot: builtinTools.capture_screenshot,
+ *     get_console_logs: builtinTools.get_console_logs,
+ *   });
+ *
+ *   // Or create custom tools
+ *   useTools({
+ *     get_weather: tool({
+ *       description: 'Get weather for a location',
+ *       inputSchema: {
+ *         type: 'object',
+ *         properties: {
+ *           location: { type: 'string' },
+ *         },
+ *         required: ['location'],
+ *       },
+ *       handler: async ({ location }) => {
+ *         const weather = await fetchWeather(location);
+ *         return success(weather);
+ *       },
+ *     }),
+ *   });
+ *
+ *   return <CopilotChat />;
+ * }
+ * ```
+ */
+declare function useTools(tools: ToolSet): void;
+
+/**
+ * Zod schema type (minimal interface)
+ */
+interface ZodObjectSchema {
+    _output: Record<string, unknown>;
+    _def: {
+        shape: () => Record<string, unknown>;
+    };
+}
+/**
+ * Configuration for registering a tool with Zod schema
+ */
+interface UseToolWithSchemaConfig<TSchema extends ZodObjectSchema> {
+    /** Unique tool name */
+    name: string;
+    /** Tool description for LLM */
+    description: string;
+    /** Zod schema for input parameters */
+    schema: TSchema;
+    /** Handler function */
+    handler: (params: TSchema["_output"], context?: ToolContext) => Promise<ToolResponse$1> | ToolResponse$1;
+    /** Optional render function for UI */
+    render?: (props: ToolRenderProps<TSchema["_output"]>) => React.ReactNode;
+    /** Whether the tool is available */
+    available?: boolean;
+}
+/**
+ * Register a client-side tool using a Zod schema
+ *
+ * This hook provides type-safe tool registration using Zod schemas.
+ * The Zod schema is automatically converted to JSON Schema for the LLM.
+ *
+ * @example
+ * ```tsx
+ * import { z } from "zod";
+ *
+ * useToolWithSchema({
+ *   name: "navigate_to_page",
+ *   description: "Navigate to a specific page in the app",
+ *   schema: z.object({
+ *     path: z.string().describe("The path to navigate to"),
+ *   }),
+ *   handler: async ({ path }) => {
+ *     // TypeScript knows `path` is a string!
+ *     router.push(path);
+ *     return { success: true, message: `Navigated to ${path}` };
+ *   },
+ * });
+ * ```
+ */
+declare function useToolWithSchema<TSchema extends ZodObjectSchema>(config: UseToolWithSchemaConfig<TSchema>, dependencies?: unknown[]): void;
+/**
+ * Register multiple client-side tools using Zod schemas
+ *
+ * @example
+ * ```tsx
+ * import { z } from "zod";
+ *
+ * useToolsWithSchema([
+ *   {
+ *     name: "navigate",
+ *     description: "Navigate to page",
+ *     schema: z.object({ path: z.string() }),
+ *     handler: async ({ path }) => { ... },
+ *   },
+ *   {
+ *     name: "open_modal",
+ *     description: "Open a modal",
+ *     schema: z.object({ modalId: z.string() }),
+ *     handler: async ({ modalId }) => { ... },
+ *   },
+ * ]);
+ * ```
+ */
+declare function useToolsWithSchema<TSchema extends ZodObjectSchema>(tools: UseToolWithSchemaConfig<TSchema>[], dependencies?: unknown[]): void;
+
+/**
+ * Tool executor return type
+ */
+interface UseToolExecutorReturn {
+    /**
+     * Execute a tool by name with given arguments
+     */
+    executeTool: (toolCall: UnifiedToolCall) => Promise<ToolResponse$1>;
+    /**
+     * Send tool result back to server
+     */
+    sendToolResult: (toolCallId: string, result: ToolResponse$1) => Promise<void>;
+    /**
+     * Get a registered tool by name
+     */
+    getTool: (name: string) => ToolDefinition | undefined;
+    /**
+     * Check if a tool is registered
+     */
+    hasTool: (name: string) => boolean;
+}
+/**
+ * Internal hook for executing client-side tools
+ *
+ * This hook is used internally by the CopilotProvider to execute
+ * tools when the server requests them via SSE events.
+ *
+ * It can also be used for custom implementations where you need
+ * direct control over tool execution.
+ *
+ * @example
+ * ```tsx
+ * const { executeTool, sendToolResult } = useToolExecutor();
+ *
+ * // When receiving a tool:execute event from server
+ * const handleToolExecute = async (event: ToolExecuteEvent) => {
+ *   const result = await executeTool({
+ *     id: event.id,
+ *     name: event.name,
+ *     input: event.args,
+ *   });
+ *
+ *   // Send result back to server
+ *   await sendToolResult(event.id, result);
+ * };
+ * ```
+ */
+declare function useToolExecutor(): UseToolExecutorReturn;
+
+/**
+ * Suggestion item
+ */
+interface Suggestion {
+    /** Suggestion text */
+    text: string;
+    /** Optional icon */
+    icon?: string;
+}
+/**
+ * useSuggestions options
+ */
+interface UseSuggestionsOptions {
+    /** Number of suggestions to show */
+    count?: number;
+    /** Context for generating suggestions */
+    context?: string;
+    /** Static suggestions (if not using AI-generated) */
+    suggestions?: Suggestion[] | string[];
+    /** Auto-refresh on conversation change */
+    autoRefresh?: boolean;
+}
+/**
+ * useSuggestions return type
+ */
+interface UseSuggestionsReturn {
+    /** Current suggestions */
+    suggestions: Suggestion[];
+    /** Whether suggestions are loading */
+    isLoading: boolean;
+    /** Refresh suggestions */
+    refresh: () => Promise<void>;
+    /** Select a suggestion (sends as message) */
+    select: (suggestion: Suggestion | string) => void;
+}
+/**
+ * Hook for chat suggestions
+ *
+ * @example
+ * ```tsx
+ * const { suggestions, select } = useSuggestions({
+ *   count: 3,
+ *   context: 'Help users with product questions',
+ * });
+ *
+ * return (
+ *   <div>
+ *     {suggestions.map((s, i) => (
+ *       <button key={i} onClick={() => select(s)}>{s.text}</button>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useSuggestions(options?: UseSuggestionsOptions): UseSuggestionsReturn;
+
+/**
+ * useAgent options
+ */
+interface UseAgentOptions<TState = Record<string, unknown>> {
+    /** Agent name */
+    name: string;
+    /** Initial state */
+    initialState?: TState;
+    /** Called when agent state changes */
+    onStateChange?: (state: TState) => void;
+}
+/**
+ * useAgent return type
+ */
+interface UseAgentReturn<TState = Record<string, unknown>> {
+    /** Current agent state */
+    state: TState;
+    /** Whether agent is running */
+    isRunning: boolean;
+    /** Current node name (for graph-based agents) */
+    nodeName: string | null;
+    /** Start the agent */
+    start: (input?: string | Record<string, unknown>) => Promise<void>;
+    /** Stop the agent */
+    stop: () => void;
+    /** Update agent state */
+    setState: (state: Partial<TState>) => void;
+    /** Error if any */
+    error: Error | null;
+}
+/**
+ * Hook for connecting to agents (LangGraph, etc.)
+ *
+ * @example
+ * ```tsx
+ * const { state, isRunning, start } = useAgent<{ city: string }>({
+ *   name: 'weather-agent',
+ *   initialState: { city: '' },
+ * });
+ *
+ * return (
+ *   <div>
+ *     <p>City: {state.city}</p>
+ *     <button onClick={() => start('What is the weather?')}>
+ *       {isRunning ? 'Running...' : 'Start'}
+ *     </button>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useAgent<TState = Record<string, unknown>>(options: UseAgentOptions<TState>): UseAgentReturn<TState>;
+
+/**
+ * Knowledge Base Search Utility
+ *
+ * Integrates with managed cloud knowledge base API to search indexed documents.
+ */
+
+type KnowledgeBaseResult = InternalKnowledgeBaseResult;
+type KnowledgeBaseConfig = InternalKnowledgeBaseConfig;
+interface KnowledgeBaseSearchResponse extends InternalKnowledgeBaseSearchResponse {
+    page?: number;
+}
+/**
+ * Search the knowledge base
+ *
+ * @param query - Search query string
+ * @param config - Knowledge base configuration
+ * @returns Search results
+ */
+declare function searchKnowledgeBase(query: string, config: KnowledgeBaseConfig): Promise<KnowledgeBaseSearchResponse>;
+/**
+ * Format knowledge base results for AI context
+ */
+declare function formatKnowledgeResultsForAI(results: KnowledgeBaseResult[]): string;
+
+/**
+ * Hook configuration for knowledge base
+ */
+interface UseKnowledgeBaseConfig {
+    /** Project UID for the knowledge base */
+    projectUid: string;
+    /** Auth token for API calls */
+    token: string;
+    /** App ID (default: "1") */
+    appId?: string;
+    /** Results limit (default: 5) */
+    limit?: number;
+    /** Whether to enable the tool (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Hook to integrate knowledge base search as a tool
+ *
+ * Registers a `search_knowledge` tool that the AI can use to search
+ * the knowledge base for relevant information.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useKnowledgeBase({
+ *     projectUid: "your-project-uid",
+ *     token: "your-auth-token",
+ *   });
+ *
+ *   return <CopilotChat />;
+ * }
+ * ```
+ */
+declare function useKnowledgeBase(config: UseKnowledgeBaseConfig): void;
+
+/**
+ * Provider capabilities for UI feature flags
+ */
+interface ProviderCapabilities {
+    /** Supports image inputs */
+    supportsVision: boolean;
+    /** Supports tool/function calling */
+    supportsTools: boolean;
+    /** Supports extended thinking (Claude, DeepSeek) */
+    supportsThinking: boolean;
+    /** Supports streaming responses */
+    supportsStreaming: boolean;
+    /** Supports PDF document inputs */
+    supportsPDF: boolean;
+    /** Supports audio inputs */
+    supportsAudio: boolean;
+    /** Supports video inputs */
+    supportsVideo: boolean;
+    /** Maximum context tokens */
+    maxTokens: number;
+    /** Supported image MIME types */
+    supportedImageTypes: string[];
+    /** Supported audio MIME types */
+    supportedAudioTypes?: string[];
+    /** Supported video MIME types */
+    supportedVideoTypes?: string[];
+    /** Supports JSON mode / structured output */
+    supportsJsonMode?: boolean;
+    /** Supports system messages */
+    supportsSystemMessages?: boolean;
+}
+/**
+ * Capabilities response from the server
+ */
+interface CapabilitiesResponse {
+    /** Provider name */
+    provider: string;
+    /** Current model ID */
+    model: string;
+    /** Model capabilities */
+    capabilities: ProviderCapabilities;
+    /** List of supported models for this provider */
+    supportedModels: string[];
+}
+/**
+ * Hook to access model capabilities from the runtime
+ *
+ * @returns Capabilities state and actions
+ *
+ * @example
+ * ```tsx
+ * function ChatInput() {
+ *   const { capabilities, isLoading } = useCapabilities();
+ *
+ *   return (
+ *     <div>
+ *       {capabilities.supportsVision && (
+ *         <ImageUploadButton />
+ *       )}
+ *       {capabilities.supportsAudio && (
+ *         <AudioRecordButton />
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCapabilities(): {
+    /** Current model capabilities */
+    capabilities: ProviderCapabilities;
+    /** Current provider name */
+    provider: string;
+    /** Current model ID */
+    model: string;
+    /** List of supported models for current provider */
+    supportedModels: string[];
+    /** Whether capabilities are being loaded */
+    isLoading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Refetch capabilities */
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook to check if a specific feature is supported
+ *
+ * @param feature - The feature to check (e.g., 'vision', 'audio', 'video')
+ * @returns Whether the feature is supported
+ *
+ * @example
+ * ```tsx
+ * function ImageButton() {
+ *   const supportsVision = useFeatureSupport('vision');
+ *
+ *   if (!supportsVision) return null;
+ *   return <button>Upload Image</button>;
+ * }
+ * ```
+ */
+declare function useFeatureSupport(feature: keyof Pick<ProviderCapabilities, "supportsVision" | "supportsTools" | "supportsThinking" | "supportsStreaming" | "supportsPDF" | "supportsAudio" | "supportsVideo" | "supportsJsonMode" | "supportsSystemMessages">): boolean;
+/**
+ * Hook to get supported media types
+ *
+ * @returns Object with supported media types
+ *
+ * @example
+ * ```tsx
+ * function MediaUpload() {
+ *   const { imageTypes, audioTypes, videoTypes } = useSupportedMediaTypes();
+ *
+ *   return (
+ *     <input
+ *       type="file"
+ *       accept={imageTypes.join(',')}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useSupportedMediaTypes(): {
+    /** Supported image MIME types */
+    imageTypes: string[];
+    /** Supported audio MIME types */
+    audioTypes: string[];
+    /** Supported video MIME types */
+    videoTypes: string[];
+    /** Whether any image types are supported */
+    hasImageSupport: boolean;
+    /** Whether any audio types are supported */
+    hasAudioSupport: boolean;
+    /** Whether any video types are supported */
+    hasVideoSupport: boolean;
+};
+
+/**
+ * SDK State for DevLogger
+ * This type is compatible with DevLoggerState in @yourgpt/copilot-sdk-ui
+ */
+interface DevLoggerState {
+    chat: {
+        isLoading: boolean;
+        messageCount: number;
+        threadId: string;
+        error: string | null;
+    };
+    tools: {
+        isEnabled: boolean;
+        isCapturing: boolean;
+        pendingConsent: boolean;
+    };
+    agentLoop: {
+        toolExecutions: Array<{
+            id: string;
+            name: string;
+            status: string;
+            approvalStatus: string;
+        }>;
+        pendingApprovals: number;
+        iteration: number;
+        maxIterations: number;
+    };
+    registered: {
+        tools: Array<{
+            name: string;
+            location: string;
+        }>;
+        actions: Array<{
+            name: string;
+        }>;
+        contextCount: number;
+    };
+    permissions: {
+        stored: Array<{
+            toolName: string;
+            level: string;
+        }>;
+        loaded: boolean;
+    };
+    config: {
+        provider: string;
+        model: string;
+        runtimeUrl: string;
+    };
+}
+/**
+ * Hook to build DevLogger state from SDK context
+ *
+ * Used internally by CopilotProvider when showLogger is true
+ */
+declare function useDevLogger(): DevLoggerState;
+
+/**
+ * Create a permission storage adapter based on config
+ */
+declare function createPermissionStorage(config: PermissionStorageConfig): PermissionStorageAdapter;
+/**
+ * Create a session-only permission cache
+ * Used for "session" permission level (in-memory, cleared on page close)
+ */
+declare function createSessionPermissionCache(): Map<string, PermissionLevel>;
+
+/**
+ * ReactChatState - React-specific implementation of ChatState
+ *
+ * This class implements the ChatState interface with callback-based
+ * reactivity for use with React's useSyncExternalStore.
+ *
+ * Pattern inspired by Vercel AI SDK's useSyncExternalStore pattern.
+ */
+
+/**
+ * ReactChatState implements ChatState with callback-based reactivity
+ *
+ * @example
+ * ```tsx
+ * const state = new ReactChatState<UIMessage>();
+ *
+ * // Subscribe to changes (for useSyncExternalStore)
+ * const unsubscribe = state.subscribe(() => {
+ *   console.log('State changed');
+ * });
+ *
+ * // Get snapshot (for useSyncExternalStore)
+ * const messages = state.messages;
+ * ```
+ */
+declare class ReactChatState<T extends UIMessage = UIMessage> implements ChatState$1<T> {
+    private _messages;
+    private _status;
+    private _error;
+    private subscribers;
+    constructor(initialMessages?: T[]);
+    get messages(): T[];
+    get status(): ChatStatus$1;
+    get error(): Error | undefined;
+    set messages(value: T[]);
+    set status(value: ChatStatus$1);
+    set error(value: Error | undefined);
+    pushMessage(message: T): void;
+    popMessage(): void;
+    replaceMessage(index: number, message: T): void;
+    updateLastMessage(updater: (message: T) => T): void;
+    setMessages(messages: T[]): void;
+    clearMessages(): void;
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   state.subscribe,
+     *   () => state.messages
+     * );
+     * ```
+     */
+    subscribe: (callback: () => void) => (() => void);
+    private notify;
+    /**
+     * Cleanup subscriptions
+     */
+    dispose(): void;
+}
+/**
+ * Create a ReactChatState instance
+ */
+declare function createReactChatState<T extends UIMessage = UIMessage>(initialMessages?: T[]): ReactChatState<T>;
+
+/**
+ * ReactChat - React-specific wrapper for AbstractChat
+ *
+ * This class extends the new AbstractChat from @yourgpt/copilot-sdk-chat
+ * and injects ReactChatState for React-specific state management.
+ *
+ * Pattern inspired by Vercel AI SDK's Chat class.
+ */
+
+/**
+ * Chat status for UI state
+ */
+type ChatStatus = "ready" | "submitted" | "streaming" | "error";
+/**
+ * ReactChat configuration
+ */
+interface ReactChatConfig {
+    /** Runtime API endpoint */
+    runtimeUrl: string;
+    /** System prompt */
+    systemPrompt?: string;
+    /** LLM configuration */
+    llm?: ChatConfig["llm"];
+    /** Thread ID */
+    threadId?: string;
+    /** Enable streaming (default: true) */
+    streaming?: boolean;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Initial messages */
+    initialMessages?: UIMessage[];
+    /** Debug mode */
+    debug?: boolean;
+    /** Callbacks */
+    callbacks?: ChatCallbacks<UIMessage>;
+}
+/**
+ * ReactChat extends AbstractChat with React-specific state management.
+ *
+ * Uses ReactChatState which implements ChatState interface with
+ * callback-based reactivity for useSyncExternalStore.
+ *
+ * @example
+ * ```tsx
+ * const chatRef = useRef(new ReactChat(config));
+ *
+ * const messages = useSyncExternalStore(
+ *   chatRef.current.subscribe,
+ *   () => chatRef.current.messages
+ * );
+ * ```
+ */
+declare class ReactChat extends AbstractChat<UIMessage> {
+    private reactState;
+    constructor(config: ReactChatConfig);
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   chat.subscribe,
+     *   () => chat.messages
+     * );
+     * ```
+     */
+    subscribe: (callback: () => void) => (() => void);
+    /**
+     * Subscribe to tool calls events
+     */
+    onToolCalls(handler: ChatEventHandler<"toolCalls">): () => void;
+    /**
+     * Subscribe to done events
+     */
+    onDone(handler: ChatEventHandler<"done">): () => void;
+    /**
+     * Subscribe to error events
+     */
+    onError(handler: ChatEventHandler<"error">): () => void;
+    dispose(): void;
+}
+/**
+ * Create a ReactChat instance
+ */
+declare function createReactChat(config: ReactChatConfig): ReactChat;
+
+/**
+ * Hook configuration
+ */
+interface UseChatConfig extends Omit<ReactChatConfig, "callbacks"> {
+    /** Callback when messages change */
+    onMessagesChange?: (messages: UIMessage[]) => void;
+    /** Callback when error occurs */
+    onError?: (error: Error | null) => void;
+    /** Callback when generation finishes */
+    onFinish?: (messages: UIMessage[]) => void;
+    /** Callback when tool calls are received */
+    onToolCalls?: (toolCalls: UIMessage["toolCalls"]) => void;
+}
+/**
+ * Hook return type
+ */
+interface UseChatReturn {
+    /** All messages */
+    messages: UIMessage[];
+    /** Current status */
+    status: ChatStatus$1;
+    /** Current error */
+    error: Error | undefined;
+    /** Whether loading */
+    isLoading: boolean;
+    /** Current input value */
+    input: string;
+    /** Set input value */
+    setInput: (input: string) => void;
+    /** Send a message */
+    sendMessage: (content: string, attachments?: MessageAttachment[]) => Promise<void>;
+    /** Stop generation */
+    stop: () => void;
+    /** Clear all messages */
+    clearMessages: () => void;
+    /** Set messages directly */
+    setMessages: (messages: UIMessage[]) => void;
+    /** Regenerate last response */
+    regenerate: (messageId?: string) => Promise<void>;
+    /** Continue with tool results */
+    continueWithToolResults: (toolResults: Array<{
+        toolCallId: string;
+        result: unknown;
+    }>) => Promise<void>;
+    /** Reference to the ReactChat instance */
+    chatRef: React.RefObject<ReactChat | null>;
+}
+/**
+ * useChat - Thin React wrapper using useSyncExternalStore
+ *
+ * This hook is designed to be minimal (~100 lines like Vercel AI SDK).
+ * All business logic lives in ReactChat/AbstractChat.
+ *
+ * @example
+ * ```tsx
+ * const { messages, sendMessage, status } = useChat({
+ *   runtimeUrl: "/api/chat",
+ * });
+ *
+ * return (
+ *   <div>
+ *     {messages.map(m => <Message key={m.id} message={m} />)}
+ *     <button onClick={() => sendMessage("Hello!")}>Send</button>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useChat(config: UseChatConfig): UseChatReturn;
+
+export { type AIContextItem, AbstractAgentLoop, AbstractChat, ActionDefinition, type AgentLoopActions, type AgentLoopCallbacks, type AgentLoopState, type CapabilitiesResponse, CapturedContext, type ChatActions, type ChatCallbacks, type ChatConfig, type ChatState, type ChatStatus, type ToolExecution as ChatToolExecution, type ToolResponse as ChatToolResponse, type CombinedChatState, CopilotConfig, type CopilotContextValue, CopilotProvider, type CopilotProviderProps, type AgentLoopState$1 as CoreAgentLoopState, type ChatState$1 as CoreChatState, type DevLoggerState, IntentDetectionResult, type KnowledgeBaseConfig, type KnowledgeBaseResult, type KnowledgeBaseSearchResponse, LLMConfig, Message, PermissionLevel, PermissionStorageAdapter, PermissionStorageConfig, type ProviderCapabilities, ReactChat, type ReactChatConfig, ReactChatState, Source, type Suggestion, ToolConsentRequest, ToolConsentResponse, ToolContext, ToolDefinition, ToolExecution$1 as ToolExecution, ToolResponse$1 as ToolResponse, ToolType, type ToolsActions, ToolsConfig, type ToolsState, type UIMessage, UnifiedToolCall, type UseAIToolsOptions, type UseAIToolsReturn, type UseAgentOptions, type UseAgentReturn, type UseChatConfig, type UseChatReturn, type UseKnowledgeBaseConfig, type UseSuggestionsOptions, type UseSuggestionsReturn, type UseToolConfig, type UseToolExecutorReturn, type UseToolWithSchemaConfig, createPermissionStorage, createReactChat, createReactChatState, createSessionPermissionCache, formatKnowledgeResultsForAI, initialAgentLoopState, searchKnowledgeBase, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useSuggestions, useSupportedMediaTypes, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };