@witqq/agent-sdk 0.6.1 → 0.7.0

package/dist/chat/react.d.cts

@@ -0,0 +1,619 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { IChatRuntime } from './runtime.cjs';
+import { ChatMessage, RuntimeStatus, SessionInfo, TextPart, ReasoningPart, ToolCallPart, SourcePart, FilePart, ChatSession, ChatEvent, ChatId, ChatIdLike, SendMessageOptions, ChatMiddleware } from './core.cjs';
+import { A as AuthToken } from '../types-CGF7AEX1.cjs';
+import { d as ModelInfo$1, T as ToolDefinition } from '../types-CqvUAYxt.cjs';
+import { CreateSessionOptions, SessionListOptions } from './sessions.cjs';
+import { ContextStats } from './context.cjs';
+import '../types-tE0CXwBl.cjs';
+import '../errors-BDLbNu9w.cjs';
+import 'zod';
+import './storage.cjs';
+
+/** Props for ChatProvider. */
+interface ChatProviderProps {
+    /** The chat runtime instance to provide to descendants. */
+    runtime: IChatRuntime;
+    children: ReactNode;
+}
+/**
+ * React context provider wrapping IChatRuntime.
+ * All chat hooks must be used within a ChatProvider.
+ */
+declare function ChatProvider({ runtime, children }: ChatProviderProps): react.FunctionComponentElement<react.ProviderProps<IChatRuntime<Record<string, unknown>> | null>>;
+/**
+ * Access the IChatRuntime from context.
+ * Must be used within a ChatProvider.
+ *
+ * @throws {Error} If used outside ChatProvider
+ */
+declare function useChatRuntime(): IChatRuntime;
+
+/** Options for the useChat hook. */
+interface UseChatOptions {
+    /** Session ID. If omitted, a new session is created on first send. */
+    sessionId?: string;
+    /** Called on error during send. */
+    onError?: (error: Error) => void;
+}
+/** Return value from useChat. */
+interface UseChatReturn {
+    /** Current session ID (null until session created). */
+    sessionId: string | null;
+    /** Ordered messages in the current session. */
+    messages: ChatMessage[];
+    /** Send a user message and trigger assistant response. */
+    sendMessage: (content: string) => Promise<void>;
+    /** Abort the current generation. */
+    stop: () => void;
+    /** Whether the assistant is currently generating. */
+    isGenerating: boolean;
+    /** Current runtime status. */
+    status: RuntimeStatus;
+    /** Current error, if any. */
+    error: Error | null;
+    /** Clear the error state. */
+    clearError: () => void;
+    /** Create a new session, resetting messages. */
+    newSession: () => Promise<string>;
+}
+/**
+ * Convenience hook for chat interaction.
+ * Wraps IChatRuntime with React state management and progressive streaming.
+ * Messages update in real-time as tokens arrive (not after full response).
+ */
+declare function useChat(options?: UseChatOptions): UseChatReturn;
+
+/** Options for the useMessages hook. */
+interface UseMessagesOptions {
+    /** Session ID to observe. */
+    sessionId: string;
+}
+/** Return value from useMessages. */
+interface UseMessagesReturn {
+    /** Ordered messages in the session. */
+    messages: ChatMessage[];
+    /** Whether the session was found. */
+    isLoaded: boolean;
+}
+/**
+ * Reactive message list via useSyncExternalStore.
+ *
+ * If the session supports subscribe/getSnapshot (reactive session),
+ * uses useSyncExternalStore for granular updates.
+ * Otherwise, falls back to polling via getSession().
+ */
+declare function useMessages(options: UseMessagesOptions): UseMessagesReturn;
+
+/**
+ * @witqq/agent-sdk/chat/react — useSessions
+ *
+ * Reactive session list hook that subscribes to runtime session changes.
+ * Auto-updates without manual polling via `onSessionChange` subscription.
+ */
+
+/** Return type of useSessions hook. */
+interface UseSessionsReturn {
+    /** Current session list (lightweight SessionInfo format) */
+    sessions: SessionInfo[];
+    /** Whether initial load or refresh is in progress */
+    loading: boolean;
+    /** Last error from session fetch */
+    error: Error | null;
+    /** Manually trigger a refresh */
+    refresh: () => void;
+}
+/**
+ * Reactive session list hook.
+ * Subscribes to `runtime.onSessionChange()` and refreshes the list automatically
+ * on create, delete, archive, and message send completion.
+ */
+declare function useSessions(): UseSessionsReturn;
+
+/** Props for the Message component. */
+interface MessageProps {
+    message: ChatMessage;
+    renderText?: (part: TextPart, index: number) => ReactNode;
+    renderReasoning?: (part: ReasoningPart, index: number) => ReactNode;
+    renderToolCall?: (part: ToolCallPart, index: number) => ReactNode;
+    renderSource?: (part: SourcePart, index: number) => ReactNode;
+    renderFile?: (part: FilePart, index: number) => ReactNode;
+}
+/**
+ * Headless message component rendering ChatMessage parts.
+ * Wraps parts in a div with data-role and data-status attributes.
+ */
+declare function Message(props: MessageProps): ReactNode;
+
+/** Props for the ThinkingBlock component. */
+interface ThinkingBlockProps {
+    text: string;
+    isStreaming?: boolean;
+    defaultOpen?: boolean;
+}
+/**
+ * Headless thinking/reasoning block using native details/summary elements.
+ * Displays "Thinking..." while streaming, "Reasoning" when complete.
+ */
+declare function ThinkingBlock({ text, isStreaming, defaultOpen }: ThinkingBlockProps): ReactNode;
+
+/** Props for the ToolCallView component. */
+interface ToolCallViewProps {
+    part: ToolCallPart;
+    onApprove?: () => void;
+    onDeny?: () => void;
+    renderArgs?: (args: unknown) => ReactNode;
+    renderResult?: (result: unknown) => ReactNode;
+}
+/**
+ * Headless tool call display component.
+ * Shows tool name, status, args, result, and approval buttons when needed.
+ */
+declare function ToolCallView({ part, onApprove, onDeny, renderArgs, renderResult }: ToolCallViewProps): ReactNode;
+
+/** A pending tool call requiring user approval. */
+interface PendingToolRequest {
+    toolCallId: string;
+    toolName: string;
+    toolArgs: Record<string, unknown>;
+    messageId: string;
+}
+/** Return value from useToolApproval. */
+interface UseToolApprovalReturn {
+    pendingRequests: PendingToolRequest[];
+    approve: (toolCallId: string) => void;
+    deny: (toolCallId: string) => void;
+}
+/**
+ * Hook that tracks tool calls requiring approval from messages.
+ *
+ * Scans messages for ToolCallParts with status "requires_approval"
+ * and provides approve/deny callbacks. Currently state-only
+ * (no ChatEventBus integration).
+ *
+ * @param messages - Messages to scan for pending tool approvals
+ * @param onApprove - Called when a tool call is approved
+ * @param onDeny - Called when a tool call is denied
+ */
+declare function useToolApproval(messages: ChatMessage[], onApprove?: (toolCallId: string) => void, onDeny?: (toolCallId: string) => void): UseToolApprovalReturn;
+
+/** Props for the MarkdownRenderer component. */
+interface MarkdownRendererProps {
+    content: string;
+    renderCode?: (code: string, language?: string) => ReactNode;
+    renderLink?: (href: string, text: string) => ReactNode;
+}
+/**
+ * Headless markdown renderer.
+ * Parses markdown text to semantic HTML elements via createElement.
+ * Supports headings, paragraphs, bold, italic, inline code, code blocks,
+ * links, blockquotes, and lists. No external dependencies.
+ */
+declare function MarkdownRenderer(props: MarkdownRendererProps): ReactNode;
+
+/** Props for the Thread component. */
+interface ThreadProps {
+    messages: ChatMessage[];
+    isGenerating?: boolean;
+    autoScroll?: boolean;
+    className?: string;
+}
+/**
+ * Headless thread component wrapping a scrollable message list.
+ * Auto-scrolls to bottom when new messages arrive unless user has scrolled up.
+ */
+declare function Thread({ messages, isGenerating, autoScroll, className, }: ThreadProps): ReactNode;
+
+/** Props for the Composer component. */
+interface ComposerProps {
+    onSend: (text: string) => void;
+    onStop?: () => void;
+    isGenerating?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    maxRows?: number;
+    className?: string;
+}
+/**
+ * Headless composer component for sending messages.
+ * Includes auto-resizing textarea, send/stop buttons, and keyboard shortcuts.
+ */
+declare function Composer({ onSend, onStop, isGenerating, disabled, placeholder, maxRows, className, }: ComposerProps): ReactNode;
+
+/** Slot override functions for Thread customization. */
+interface ThreadSlotOverrides {
+    renderMessage?: (message: ChatMessage, index: number) => ReactNode;
+    renderToolCall?: (part: ToolCallPart, index: number) => ReactNode;
+    renderThinkingBlock?: (part: ReasoningPart, index: number) => ReactNode;
+}
+/** Props for ThreadProvider. */
+interface ThreadProviderProps extends ThreadSlotOverrides {
+    children: ReactNode;
+}
+/**
+ * Provides slot-based customization for Thread message rendering.
+ * Wrap a Thread in ThreadProvider to override how messages, tool calls,
+ * or thinking blocks are rendered.
+ */
+declare function ThreadProvider({ children, renderMessage, renderToolCall, renderThinkingBlock, }: ThreadProviderProps): ReactNode;
+/**
+ * Access slot overrides from ThreadProvider context.
+ * @throws {Error} If used outside a ThreadProvider
+ */
+declare function useThreadSlots(): ThreadSlotOverrides;
+/**
+ * Access slot overrides if inside a ThreadProvider, or null if not.
+ * Safe to call without a ThreadProvider ancestor.
+ */
+declare function useOptionalThreadSlots(): ThreadSlotOverrides | null;
+
+/** A session item that ThreadList can display — either full ChatSession or lightweight SessionInfo. */
+type SessionItem = SessionInfo | ChatSession;
+/** Props for the ThreadList component. */
+interface ThreadListProps {
+    sessions: SessionItem[];
+    activeSessionId?: string;
+    onSelect: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    searchQuery?: string;
+    onSearchChange?: (query: string) => void;
+    className?: string;
+}
+/**
+ * Session sidebar component for listing, searching, creating, and deleting sessions.
+ */
+declare function ThreadList({ sessions, activeSessionId, onSelect, onCreate, onDelete, searchQuery, onSearchChange, className, }: ThreadListProps): ReactNode;
+
+/** Connection status of the SSE hook. */
+type SSEStatus = "idle" | "connecting" | "open" | "closed" | "error";
+/** Options for the useSSE hook. */
+interface UseSSEOptions {
+    headers?: Record<string, string>;
+    onEvent?: (event: ChatEvent) => void;
+    onError?: (error: Error) => void;
+    reconnect?: boolean;
+    reconnectInterval?: number;
+}
+/** Return type for the useSSE hook. */
+interface UseSSEReturn {
+    status: SSEStatus;
+    connect: () => void;
+    disconnect: () => void;
+    lastEvent: ChatEvent | null;
+}
+/**
+ * SSE transport hook using fetch (not EventSource).
+ * Parses text/event-stream format with support for multi-line data and event types.
+ */
+declare function useSSE(url: string | null, options?: UseSSEOptions): UseSSEReturn;
+
+/** Model display option returned by useModels (mapped from core ModelInfo). */
+interface ModelOption {
+    id: string;
+    name: string;
+    tier?: string;
+}
+/** @deprecated Use ModelOption instead — renamed to avoid collision with core ModelInfo */
+type ModelInfo = ModelOption;
+/** Return type for the useModels hook. */
+interface UseModelsReturn {
+    models: ModelOption[];
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => void;
+    search: (query: string) => ModelOption[];
+}
+/**
+ * Hook for fetching and searching available models from the chat runtime.
+ */
+declare function useModels(): UseModelsReturn;
+
+/** Props for the ModelSelector component. */
+interface ModelSelectorProps {
+    models: ModelOption[];
+    selectedModel?: string;
+    onSelect: (modelId: string) => void;
+    placeholder?: string;
+    className?: string;
+}
+/**
+ * Dropdown model selector with search and keyboard navigation.
+ */
+declare function ModelSelector({ models, selectedModel, onSelect, placeholder, className, }: ModelSelectorProps): ReactNode;
+
+/** Supported auth backends. */
+type AuthBackend = "copilot" | "claude" | "api-key";
+/** Auth status state machine: idle → pending → authenticated | error. */
+type AuthStatus = "idle" | "pending" | "authenticated" | "error";
+/** Options for the useAuth hook. */
+interface UseAuthOptions {
+    backend: AuthBackend;
+    onAuthenticated?: (token: AuthToken) => void;
+}
+/** Return value from useAuth. */
+interface UseAuthReturn {
+    status: AuthStatus;
+    error: Error | null;
+    startDeviceFlow: () => Promise<void>;
+    deviceCode: string | null;
+    verificationUrl: string | null;
+    startOAuthFlow: () => Promise<void>;
+    authorizeUrl: string | null;
+    completeOAuth: (codeOrUrl: string) => Promise<void>;
+    submitApiKey: (key: string) => void;
+    token: AuthToken | null;
+    reset: () => void;
+}
+/**
+ * Hook for multi-backend authentication.
+ *
+ * Wraps CopilotAuth (Device Flow), ClaudeAuth (OAuth+PKCE),
+ * and plain API key validation into a unified React state machine.
+ *
+ * @deprecated Use `useRemoteAuth` instead for browser contexts.
+ * `useAuth` directly instantiates auth classes which require `node:crypto`
+ * (via ClaudeAuth). The `useRemoteAuth` hook delegates authentication to
+ * server endpoints (createAuthHandler), avoiding browser crypto dependencies.
+ *
+ * Migration: replace `useAuth({ backend })` with
+ * `useRemoteAuth({ backend, baseUrl: "/api/auth" })`.
+ * Note: the `"api-key"` backend is renamed to `"vercel-ai"` in useRemoteAuth,
+ * and `submitApiKey` is now async (returns Promise<void>).
+ * The return interface is otherwise compatible — `startDeviceFlow`, `startOAuthFlow`,
+ * `completeOAuth`, `submitApiKey`, `token`, `status`, `error`, `reset`
+ * all work the same way.
+ */
+declare function useAuth(options: UseAuthOptions): UseAuthReturn;
+
+/**
+ * @witqq/agent-sdk/chat/react — useRemoteAuth
+ *
+ * Server-delegated authentication hook. Delegates all auth flows to
+ * the server auth handler (createAuthHandler) via HTTP, avoiding
+ * browser crypto dependencies entirely.
+ *
+ * Replaces useAuth for browser contexts. Same interface shape for easy migration.
+ */
+
+/** Supported remote auth backends. */
+type RemoteAuthBackend = "copilot" | "claude" | "vercel-ai";
+/** Auth status state machine: idle → pending → authenticated | error. */
+type RemoteAuthStatus = "idle" | "pending" | "authenticated" | "error";
+/** Options for the useRemoteAuth hook. */
+interface UseRemoteAuthOptions {
+    /** Auth backend to use */
+    backend: RemoteAuthBackend;
+    /** Base URL of the auth server (e.g. "http://localhost:3456/api/auth") */
+    baseUrl: string;
+    /** Called after successful authentication */
+    onAuthenticated?: (token: AuthToken) => void;
+    /** Optional fetch override (for testing) */
+    fetch?: typeof globalThis.fetch;
+    /** Optional headers for all requests */
+    headers?: Record<string, string>;
+}
+/** Return value from useRemoteAuth. */
+interface UseRemoteAuthReturn {
+    status: RemoteAuthStatus;
+    error: Error | null;
+    startDeviceFlow: () => Promise<void>;
+    deviceCode: string | null;
+    verificationUrl: string | null;
+    startOAuthFlow: () => Promise<void>;
+    authorizeUrl: string | null;
+    completeOAuth: (codeOrUrl: string) => Promise<void>;
+    submitApiKey: (key: string, baseUrl?: string) => Promise<void>;
+    start: (provider?: RemoteAuthBackend) => Promise<void>;
+    token: AuthToken | null;
+    reset: () => void;
+    savedProviders: string[];
+    loadSavedTokens: () => Promise<void>;
+    useSavedToken: (provider: RemoteAuthBackend) => Promise<void>;
+    clearTokens: () => Promise<void>;
+}
+/**
+ * Server-delegated authentication hook.
+ *
+ * Communicates with server auth handler endpoints (POST /auth/start,
+ * POST /auth/copilot/poll, etc.) instead of running auth flows in the browser.
+ * No node:crypto dependency since all crypto operations happen server-side.
+ *
+ * @param options - Hook configuration
+ * @returns Auth state and action methods
+ *
+ * @example
+ * ```ts
+ * const auth = useRemoteAuth({
+ *   backend: "copilot",
+ *   baseUrl: "/api/auth",
+ *   onAuthenticated: (token) => console.log("Authenticated:", token),
+ * });
+ * ```
+ */
+declare function useRemoteAuth(options: UseRemoteAuthOptions): UseRemoteAuthReturn;
+
+/**
+ * @witqq/agent-sdk/chat/react — useRemoteChat
+ *
+ * Lifecycle hook that orchestrates auth → runtime → session.
+ *
+ * On mount, checks for saved auth tokens and auto-restores.
+ * Once authenticated, creates a RemoteChatRuntime and initial session.
+ * Exposes readiness phase, the runtime instance, and the auth sub-hook.
+ */
+
+/** Lifecycle phase for the useRemoteChat hook. */
+type RemoteChatPhase = "initializing" | "unauthenticated" | "authenticating" | "creating" | "ready" | "error";
+/** Options for useRemoteChat. */
+interface UseRemoteChatOptions {
+    /** Base URL for chat API (e.g. "/api/chat"). */
+    chatBaseUrl: string;
+    /** Base URL for auth API (e.g. "/api/auth"). */
+    authBaseUrl: string;
+    /** Auth backend to use. */
+    backend: RemoteAuthBackend;
+    /** Called when lifecycle reaches "ready" phase. */
+    onReady?: () => void;
+    /** Custom fetch for testability. */
+    fetch?: typeof globalThis.fetch;
+    /** Optional headers for all requests. */
+    headers?: Record<string, string>;
+    /** Auto-restore saved tokens on mount (default: true). */
+    autoRestore?: boolean;
+}
+/** Return value from useRemoteChat. */
+interface UseRemoteChatReturn {
+    /** Current lifecycle phase. */
+    phase: RemoteChatPhase;
+    /** Chat runtime (null until phase = "ready"). */
+    runtime: IChatRuntime | null;
+    /** Initial session ID (null until phase = "ready"). */
+    sessionId: string | null;
+    /** Auth sub-hook for manual auth control. */
+    auth: UseRemoteAuthReturn;
+    /** Current error (null when no error). */
+    error: Error | null;
+    /** Create a new chat session. Returns session ID. */
+    newSession: () => Promise<string>;
+    /** Logout: clear tokens, dispose runtime, reset to unauthenticated. */
+    logout: () => Promise<void>;
+}
+/**
+ * Lifecycle hook: auth → runtime → session.
+ *
+ * @example
+ * ```tsx
+ * const chat = useRemoteChat({
+ *   chatBaseUrl: "/api/chat",
+ *   authBaseUrl: "/api/auth",
+ *   backend: "copilot",
+ * });
+ *
+ * if (chat.phase === "unauthenticated") {
+ *   return <button onClick={() => chat.auth.start()}>Login</button>;
+ * }
+ * if (chat.phase === "ready" && chat.runtime) {
+ *   return <ChatProvider runtime={chat.runtime}>...</ChatProvider>;
+ * }
+ * ```
+ */
+declare function useRemoteChat(options: UseRemoteChatOptions): UseRemoteChatReturn;
+
+/** Props for the AuthDialog component. */
+interface AuthDialogProps {
+    backends: AuthBackend[];
+    selectedBackend?: AuthBackend;
+    onBackendChange?: (backend: AuthBackend) => void;
+    onAuthenticated?: (token: AuthToken) => void;
+    renderCopilotFlow?: (state: {
+        deviceCode: string;
+        verificationUrl: string;
+        status: AuthStatus;
+    }) => ReactNode;
+    renderClaudeFlow?: (state: {
+        authorizeUrl: string | null;
+        status: AuthStatus;
+        completeOAuth: (code: string) => Promise<void>;
+    }) => ReactNode;
+    renderApiKeyFlow?: (state: {
+        submitApiKey: (key: string) => void;
+        status: AuthStatus;
+    }) => ReactNode;
+    className?: string;
+}
+/**
+ * Multi-backend auth dialog component.
+ *
+ * Headless component that renders backend selector buttons and
+ * per-backend auth flows. Uses data attributes for styling hooks.
+ * Supports custom render props for each flow type.
+ */
+declare function AuthDialog({ backends, selectedBackend: controlledBackend, onBackendChange, onAuthenticated, renderCopilotFlow, renderClaudeFlow, renderApiKeyFlow, className, }: AuthDialogProps): ReactNode;
+
+/**
+ * Client-side runtime adapter that implements IChatRuntime by delegating
+ * operations over HTTP/SSE to a remote server.
+ *
+ * Bridges the gap between SDK React hooks (which require an in-process runtime)
+ * and the common architecture where ChatRuntime runs on a server.
+ *
+ * @example
+ * ```ts
+ * import { RemoteChatRuntime } from "@witqq/agent-sdk/chat/react";
+ * import { ChatProvider } from "@witqq/agent-sdk/chat/react";
+ *
+ * const runtime = new RemoteChatRuntime({ baseUrl: "/api" });
+ * <ChatProvider runtime={runtime}> ... </ChatProvider>
+ * ```
+ */
+
+/**
+ * Standard server endpoint contract.
+ * Server implementations expose these routes to work with RemoteChatRuntime.
+ *
+ * POST   {baseUrl}/sessions/create   — Create session
+ * GET    {baseUrl}/sessions/{id}     — Get session
+ * GET    {baseUrl}/sessions          — List sessions
+ * DELETE {baseUrl}/sessions/{id}     — Delete session
+ * POST   {baseUrl}/sessions/{id}/archive — Archive session
+ * POST   {baseUrl}/send              — Send message (SSE stream response)
+ * POST   {baseUrl}/abort             — Abort current stream
+ * GET    {baseUrl}/models            — List models
+ * POST   {baseUrl}/backend/switch    — Switch backend
+ * POST   {baseUrl}/model/switch      — Switch model
+ */
+interface RemoteChatRuntimeOptions {
+    /** Base URL for API endpoints (e.g. "/api" or "https://example.com/api") */
+    baseUrl: string;
+    /** Optional headers for all requests (e.g. auth tokens) */
+    headers?: Record<string, string>;
+    /** Custom fetch implementation for testability */
+    fetch?: typeof globalThis.fetch;
+}
+declare class RemoteChatRuntime implements IChatRuntime {
+    private _status;
+    private _activeSessionId;
+    private _currentBackend;
+    private _currentModel;
+    private _abortController;
+    private readonly _tools;
+    private readonly _middlewares;
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly _fetch;
+    constructor(options: RemoteChatRuntimeOptions);
+    get status(): RuntimeStatus;
+    dispose(): Promise<void>;
+    private assertNotDisposed;
+    get activeSessionId(): ChatId | null;
+    createSession(options: CreateSessionOptions): Promise<ChatSession>;
+    getSession(id: ChatIdLike): Promise<ChatSession | null>;
+    listSessions(_options?: SessionListOptions): Promise<ChatSession[]>;
+    deleteSession(id: ChatIdLike): Promise<void>;
+    archiveSession(id: ChatIdLike): Promise<void>;
+    switchSession(id: ChatIdLike): Promise<ChatSession>;
+    send(sessionId: ChatIdLike, message: string, options?: SendMessageOptions): AsyncIterable<ChatEvent>;
+    abort(): void;
+    get currentBackend(): string;
+    get currentModel(): string | undefined;
+    switchBackend(name: string): Promise<void>;
+    switchModel(model: string): void;
+    listModels(): Promise<ModelInfo$1[]>;
+    get registeredTools(): ReadonlyMap<string, ToolDefinition>;
+    registerTool(tool: ToolDefinition): void;
+    removeTool(name: string): void;
+    use(middleware: ChatMiddleware): void;
+    removeMiddleware(middleware: ChatMiddleware): void;
+    getContextStats(_sessionId: ChatIdLike): ContextStats | null;
+    private readonly _sessionListeners;
+    onSessionChange(callback: () => void): () => void;
+    private _notifySessionChange;
+    private _get;
+    private _post;
+    private _delete;
+    private _parseSSEStream;
+}
+
+export { type AuthBackend, AuthDialog, type AuthDialogProps, type AuthStatus, ChatProvider, Composer, type ComposerProps, MarkdownRenderer, type MarkdownRendererProps, Message, type MessageProps, type ModelInfo, type ModelOption, ModelSelector, type ModelSelectorProps, type PendingToolRequest, type RemoteAuthBackend, type RemoteAuthStatus, type RemoteChatPhase, RemoteChatRuntime, type RemoteChatRuntimeOptions, type SSEStatus, ThinkingBlock, type ThinkingBlockProps, Thread, ThreadList, type ThreadListProps, type ThreadProps, ThreadProvider, type ThreadProviderProps, type ThreadSlotOverrides, ToolCallView, type ToolCallViewProps, type UseAuthOptions, type UseAuthReturn, type UseChatOptions, type UseChatReturn, type UseMessagesOptions, type UseMessagesReturn, type UseModelsReturn, type UseRemoteAuthOptions, type UseRemoteAuthReturn, type UseRemoteChatOptions, type UseRemoteChatReturn, type UseSSEOptions, type UseSSEReturn, type UseSessionsReturn, type UseToolApprovalReturn, useAuth, useChat, useChatRuntime, useMessages, useModels, useOptionalThreadSlots, useRemoteAuth, useRemoteChat, useSSE, useSessions, useThreadSlots, useToolApproval };