@reverbia/sdk 1.0.0 → 1.1.0-next.20251230221037

package/dist/expo/index.d.ts

@@ -0,0 +1,1217 @@
+import { Database, Model } from '@nozbe/watermelondb';
+import * as _nozbe_watermelondb_Schema_migrations from '@nozbe/watermelondb/Schema/migrations';
+import * as _nozbe_watermelondb_Schema from '@nozbe/watermelondb/Schema';
+import Model$1, { Associations } from '@nozbe/watermelondb/Model';
+import { Class } from '@nozbe/watermelondb/types';
+
+/**
+ * ExtraFields contains additional metadata such as provider/model information.
+ */
+type LlmapiImageGenerationExtraFields = {
+    /**
+     * ModelRequested is the model identifier that the client asked for.
+     */
+    model_requested?: string;
+    /**
+     * Provider is the gateway that serviced this request.
+     */
+    provider?: string;
+    /**
+     * RequestType is always "image_generation".
+     */
+    request_type?: string;
+};
+type LlmapiImageGenerationImage = {
+    /**
+     * B64JSON is the base64 payload for models that can only return binary.
+     */
+    b64_json?: string;
+    /**
+     * URL is the signed URL to download the image.
+     */
+    url?: string;
+};
+type LlmapiImageGenerationRequest = {
+    /**
+     * Model is the model identifier to use for generation (e.g., "gpt-image-1").
+     */
+    model: string;
+    /**
+     * Prompt is the text description of the desired image.
+     */
+    prompt: string;
+    /**
+     * Quality targets a quality preset (e.g., "auto", "high").
+     */
+    quality?: string;
+    /**
+     * ResponseFormat controls how the generated image is returned (e.g., "url" or "b64_json").
+     */
+    response_format?: string;
+    /**
+     * Size controls the dimensions of the generated image (e.g., "1024x1024").
+     */
+    size?: string;
+};
+type LlmapiImageGenerationResponse = {
+    /**
+     * Created is the Unix timestamp when the image was generated.
+     */
+    created?: number;
+    extra_fields?: LlmapiImageGenerationExtraFields;
+    /**
+     * Images contains the generated images.
+     */
+    images?: Array<LlmapiImageGenerationImage>;
+    /**
+     * Model is the model identifier that generated the image.
+     */
+    model?: string;
+    /**
+     * Provider is the gateway that produced the image.
+     */
+    provider?: string;
+    usage?: LlmapiImageGenerationUsage;
+};
+/**
+ * Usage documents token usage (when available).
+ */
+type LlmapiImageGenerationUsage = {
+    /**
+     * CostMicroUSD is the inference cost for this image generation request
+     */
+    cost_micro_usd?: number;
+    /**
+     * InputTokens is the number of tokens sent in the prompt.
+     */
+    input_tokens?: number;
+    /**
+     * OutputTokens is the number of tokens returned by the model.
+     */
+    output_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens consumed.
+     */
+    total_tokens?: number;
+};
+/**
+ * Message is the generated message
+ */
+type LlmapiMessage = {
+    /**
+     * Content is the message content
+     */
+    content?: Array<LlmapiMessageContentPart>;
+    role?: LlmapiRole;
+    /**
+     * ToolCalls contains tool/function calls made by the assistant (only for assistant role)
+     */
+    tool_calls?: Array<LlmapiToolCall>;
+};
+/**
+ * ImageURL is used when Type=image_url
+ */
+type LlmapiMessageContentImage = {
+    /**
+     * Detail is the OpenAI detail hint (auto|low|high)
+     */
+    detail?: string;
+    /**
+     * URL is the image URL or data URI
+     */
+    url?: string;
+};
+type LlmapiMessageContentPart = {
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text` or `image_url`)
+     */
+    type?: string;
+};
+type LlmapiModel = {
+    architecture?: LlmapiModelArchitecture;
+    /**
+     * CanonicalSlug is the canonical slug for the model
+     */
+    canonical_slug?: string;
+    /**
+     * ContextLength is the maximum context length in tokens
+     */
+    context_length?: number;
+    /**
+     * Created is the Unix timestamp of when the model was created
+     */
+    created?: number;
+    /**
+     * DefaultParameters contains default parameter values
+     */
+    default_parameters?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Description describes the model and its capabilities
+     */
+    description?: string;
+    /**
+     * HuggingFaceID is the Hugging Face model identifier
+     */
+    hugging_face_id?: string;
+    /**
+     * ID is the model identifier (e.g., "openai/gpt-4")
+     */
+    id?: string;
+    /**
+     * MaxInputTokens is the maximum input tokens
+     */
+    max_input_tokens?: number;
+    /**
+     * MaxOutputTokens is the maximum output tokens
+     */
+    max_output_tokens?: number;
+    /**
+     * Modalities is a list of supported modalities (e.g., ["llm", "vision"])
+     */
+    modalities?: Array<string>;
+    /**
+     * Name is the human-readable model name (optional)
+     */
+    name?: string;
+    /**
+     * OwnedBy is the organization that owns the model
+     */
+    owned_by?: string;
+    per_request_limits?: LlmapiModelPerRequestLimits;
+    pricing?: LlmapiModelPricing;
+    /**
+     * SupportedMethods is a list of supported API methods
+     */
+    supported_methods?: Array<string>;
+    /**
+     * SupportedParameters is a list of supported parameter names
+     */
+    supported_parameters?: Array<string>;
+    top_provider?: LlmapiModelTopProvider;
+};
+/**
+ * Architecture describes the model's technical capabilities
+ */
+type LlmapiModelArchitecture = {
+    instruct_type?: string;
+    modality?: string;
+    prompt_formatting?: string;
+    tokenizer?: string;
+};
+/**
+ * PerRequestLimits contains rate limiting information
+ */
+type LlmapiModelPerRequestLimits = {
+    completion_tokens?: number;
+    prompt_tokens?: number;
+};
+/**
+ * Pricing contains the pricing structure for using this model
+ */
+type LlmapiModelPricing = {
+    completion?: string;
+    image?: string;
+    prompt?: string;
+    request?: string;
+};
+/**
+ * TopProvider contains configuration details for the primary provider
+ */
+type LlmapiModelTopProvider = {
+    context_length?: number;
+    is_moderated?: boolean;
+    max_completion_tokens?: number;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiResponseExtraFields = {
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * ModelRequested is the model that was requested
+     */
+    model_requested?: string;
+    /**
+     * Provider is the LLM provider used (e.g., "openai", "anthropic")
+     */
+    provider?: string;
+    /**
+     * RequestType is always "responses"
+     */
+    request_type?: string;
+};
+type LlmapiResponseOutputContent = {
+    /**
+     * Text is the text content
+     */
+    text?: string;
+    /**
+     * Type is the content type (e.g., "output_text")
+     */
+    type?: string;
+};
+type LlmapiResponseOutputItem = {
+    /**
+     * Arguments is the function arguments for function_call types
+     */
+    arguments?: string;
+    /**
+     * CallID is the call ID for function_call types
+     */
+    call_id?: string;
+    /**
+     * Content is the content array for message and reasoning types
+     */
+    content?: Array<LlmapiResponseOutputContent>;
+    /**
+     * ID is the unique identifier for this output item
+     */
+    id?: string;
+    /**
+     * Name is the function name for function_call types
+     */
+    name?: string;
+    /**
+     * Role is the role for message types (e.g., "assistant")
+     */
+    role?: string;
+    /**
+     * Status is the status of this output item (e.g., "completed")
+     */
+    status?: string;
+    /**
+     * Summary is the reasoning summary for reasoning types
+     */
+    summary?: Array<LlmapiResponseOutputContent>;
+    /**
+     * Type is the output item type (e.g., "message", "function_call", "reasoning")
+     */
+    type?: string;
+};
+/**
+ * Reasoning configures reasoning for o-series and other reasoning models
+ */
+type LlmapiResponseReasoning = {
+    /**
+     * Effort controls reasoning effort: "low", "medium", or "high"
+     */
+    effort?: string;
+    /**
+     * Summary controls reasoning summary: "auto", "concise", or "detailed"
+     */
+    summary?: string;
+};
+type LlmapiResponseResponse = {
+    /**
+     * Created is the Unix timestamp of creation (created_at in OpenAI format)
+     */
+    created_at?: number;
+    extra_fields?: LlmapiResponseExtraFields;
+    /**
+     * ID is the unique response identifier
+     */
+    id?: string;
+    /**
+     * Model is the model used for generation
+     */
+    model?: string;
+    /**
+     * Object is the response type (e.g., "response")
+     */
+    object?: string;
+    /**
+     * Output is the array of output items (OpenAI Responses API format)
+     */
+    output?: Array<LlmapiResponseOutputItem>;
+    usage?: LlmapiResponseUsage;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiResponseUsage = {
+    /**
+     * CompletionTokens is the number of tokens in the completion
+     */
+    completion_tokens?: number;
+    /**
+     * CostMicroUSD is the cost of this response in micro-dollars (USD × 1,000,000)
+     */
+    cost_micro_usd?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+/**
+ * Role is the message role (system, user, assistant)
+ */
+type LlmapiRole = string;
+/**
+ * Thinking configures extended thinking for Anthropic models
+ */
+type LlmapiThinkingOptions = {
+    /**
+     * BudgetTokens is the token budget for thinking
+     */
+    budget_tokens?: number;
+    /**
+     * Type indicates if thinking is enabled: "enabled" or "disabled"
+     */
+    type?: string;
+};
+type LlmapiTool = {
+    function?: LlmapiToolFunction;
+    /**
+     * Type is the tool type (function, code_interpreter, file_search, web_search)
+     */
+    type?: string;
+};
+type LlmapiToolCall = {
+    function?: LlmapiToolCallFunction;
+    /**
+     * ID is the unique identifier for this tool call
+     */
+    id?: string;
+    /**
+     * Type is the type of tool call (always "function" for now)
+     */
+    type?: string;
+};
+/**
+ * Function contains the function call details
+ */
+type LlmapiToolCallFunction = {
+    /**
+     * Arguments is the JSON string of arguments to pass to the function
+     */
+    arguments?: string;
+    /**
+     * Name is the name of the function to call
+     */
+    name?: string;
+};
+/**
+ * Function is the function definition (when Type is "function")
+ */
+type LlmapiToolFunction = {
+    /**
+     * Arguments is the function arguments schema (JSON object)
+     */
+    arguments?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Name is the function name
+     */
+    name?: string;
+};
+
+/**
+ * Responses API options that can be passed to sendMessage
+ */
+type ResponsesApiOptions = {
+    /**
+     * Whether to store the response server-side.
+     * When true, the response can be retrieved later using the response ID.
+     */
+    store?: boolean;
+    /**
+     * ID of a previous response to continue from.
+     * Enables multi-turn conversations without resending full history.
+     */
+    previousResponseId?: string;
+    /**
+     * Conversation ID for grouping related responses.
+     */
+    conversation?: string;
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     * Lower values make output more deterministic.
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Array of tool definitions available to the model.
+     */
+    tools?: LlmapiTool[];
+    /**
+     * Controls which tool to use: "auto", "any", "none", "required", or a specific tool name.
+     */
+    toolChoice?: string;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort and summary output.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step.
+     */
+    thinking?: LlmapiThinkingOptions;
+};
+/**
+ * Base arguments for sending a message
+ */
+type BaseSendMessageArgs = ResponsesApiOptions & {
+    messages: LlmapiMessage[];
+    model?: string;
+    /**
+     * Per-request callback for data chunks. Called in addition to the global
+     * `onData` callback if provided in `useChat` options.
+     *
+     * @param chunk - The content delta from the current chunk
+     */
+    onData?: (chunk: string) => void;
+};
+/**
+ * Base result type for sendMessage
+ */
+type BaseSendMessageResult = {
+    data: LlmapiResponseResponse;
+    error: null;
+} | {
+    data: null;
+    error: string;
+};
+/**
+ * Base options for useChat hook
+ */
+type BaseUseChatOptions = {
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    /**
+     * Callback function to be called when a new data chunk is received.
+     */
+    onData?: (chunk: string) => void;
+    /**
+     * Callback function to be called when thinking/reasoning content is received.
+     * This is called with delta chunks as the model "thinks" through a problem.
+     */
+    onThinking?: (chunk: string) => void;
+    /**
+     * Callback function to be called when the chat completion finishes successfully.
+     */
+    onFinish?: (response: LlmapiResponseResponse) => void;
+    /**
+     * Callback function to be called when an unexpected error is encountered.
+     *
+     * **Note:** This callback is NOT called for aborted requests (via `stop()` or
+     * component unmount). Aborts are intentional actions and are not considered
+     * errors. To detect aborts, check the `error` field in the `sendMessage` result:
+     * `result.error === "Request aborted"`.
+     *
+     * @param error - The error that occurred (never an AbortError)
+     */
+    onError?: (error: Error) => void;
+};
+/**
+ * Base result type for useChat hook
+ */
+type BaseUseChatResult = {
+    isLoading: boolean;
+    /**
+     * Aborts the current streaming request if one is in progress.
+     *
+     * When a request is aborted, `sendMessage` will return with
+     * `{ data: null, error: "Request aborted" }`. The `onError` callback
+     * will NOT be called, as aborts are intentional actions, not errors.
+     */
+    stop: () => void;
+};
+
+type SendMessageArgs = BaseSendMessageArgs & {
+    /**
+     * Per-request callback for thinking/reasoning chunks.
+     */
+    onThinking?: (chunk: string) => void;
+};
+type SendMessageResult = BaseSendMessageResult;
+type UseChatOptions = BaseUseChatOptions;
+type UseChatResult = BaseUseChatResult & {
+    sendMessage: (args: SendMessageArgs) => Promise<SendMessageResult>;
+};
+/**
+ * A React hook for managing chat completions with authentication.
+ *
+ * **React Native version** - This is a lightweight version that only supports
+ * API-based chat completions. Local chat and client-side tools are not available
+ * in React Native.
+ *
+ * @param options - Optional configuration object
+ * @param options.getToken - An async function that returns an authentication token.
+ * @param options.baseUrl - Optional base URL for the API requests.
+ * @param options.onData - Callback function to be called when a new data chunk is received.
+ * @param options.onFinish - Callback function to be called when the chat completion finishes successfully.
+ * @param options.onError - Callback function to be called when an unexpected error is encountered.
+ *
+ * @returns An object containing:
+ *   - `isLoading`: A boolean indicating whether a request is currently in progress
+ *   - `sendMessage`: An async function to send chat messages
+ *   - `stop`: A function to abort the current request
+ *
+ * @category Hooks
+ *
+ * @example
+ * ```tsx
+ * const { isLoading, sendMessage, stop } = useChat({
+ *   getToken: async () => await getAuthToken(),
+ *   onFinish: (response) => console.log("Chat finished:", response),
+ *   onError: (error) => console.error("Chat error:", error)
+ * });
+ *
+ * const handleSend = async () => {
+ *   const result = await sendMessage({
+ *     messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello!' }] }],
+ *     model: 'gpt-4o-mini'
+ *   });
+ * };
+ * ```
+ */
+declare function useChat(options?: UseChatOptions): UseChatResult;
+
+declare const chatStorageSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+declare const chatStorageMigrations: Readonly<{
+    validated: true;
+    minVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    maxVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    sortedMigrations: _nozbe_watermelondb_Schema_migrations.Migration[];
+}>;
+
+interface MemoryItem$1 {
+    type: "identity" | "preference" | "project" | "skill" | "constraint";
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+interface MemoryExtractionResult {
+    items: MemoryItem$1[];
+}
+
+type MemoryType = "identity" | "preference" | "project" | "skill" | "constraint";
+interface MemoryItem {
+    type: MemoryType;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+interface CreateMemoryOptions extends MemoryItem {
+    embedding?: number[];
+    embeddingModel?: string;
+}
+type UpdateMemoryOptions = Partial<CreateMemoryOptions>;
+interface StoredMemory extends MemoryItem {
+    uniqueId: string;
+    compositeKey: string;
+    uniqueKey: string;
+    createdAt: Date;
+    updatedAt: Date;
+    embedding?: number[];
+    embeddingModel?: string;
+    isDeleted: boolean;
+}
+interface StoredMemoryWithSimilarity extends StoredMemory {
+    similarity: number;
+}
+interface BaseUseMemoryStorageOptions {
+    database: Database;
+    completionsModel?: string;
+    embeddingModel?: string | null;
+    generateEmbeddings?: boolean;
+    onFactsExtracted?: (facts: MemoryExtractionResult) => void;
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - migration disabled if not provided) */
+    signMessage?: (message: string) => Promise<string>;
+}
+interface BaseUseMemoryStorageResult {
+    memories: StoredMemory[];
+    refreshMemories: () => Promise<void>;
+    extractMemoriesFromMessage: (options: {
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        model?: string;
+    }) => Promise<MemoryExtractionResult | null>;
+    searchMemories: (query: string, limit?: number, minSimilarity?: number) => Promise<StoredMemoryWithSimilarity[]>;
+    fetchAllMemories: () => Promise<StoredMemory[]>;
+    fetchMemoriesByNamespace: (namespace: string) => Promise<StoredMemory[]>;
+    fetchMemoriesByKey: (namespace: string, key: string) => Promise<StoredMemory[]>;
+    getMemoryById: (id: string) => Promise<StoredMemory | null>;
+    saveMemory: (memory: CreateMemoryOptions) => Promise<StoredMemory>;
+    saveMemories: (memories: CreateMemoryOptions[]) => Promise<StoredMemory[]>;
+    updateMemory: (id: string, updates: UpdateMemoryOptions) => Promise<StoredMemory | null>;
+    removeMemory: (namespace: string, key: string, value: string) => Promise<void>;
+    removeMemoryById: (id: string) => Promise<void>;
+    removeMemories: (namespace: string, key: string) => Promise<void>;
+    clearMemories: () => Promise<void>;
+}
+declare function generateCompositeKey(namespace: string, key: string): string;
+declare function generateUniqueKey(namespace: string, key: string, value: string): string;
+
+type ChatRole = "user" | "assistant" | "system";
+interface FileMetadata {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url?: string;
+}
+interface ChatCompletionUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    costMicroUsd?: number;
+}
+interface SearchSource {
+    title?: string;
+    url?: string;
+    snippet?: string;
+    date?: string;
+}
+interface StoredMessage {
+    uniqueId: string;
+    messageId: number;
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    files?: FileMetadata[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    wasStopped?: boolean;
+    /** If set, indicates the message failed with this error */
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string;
+}
+interface ActivityPhase {
+    id: string;
+    label: string;
+    timestamp: number;
+    status: "pending" | "active" | "completed";
+    data?: StoredMemory[];
+}
+interface StoredConversation {
+    uniqueId: string;
+    conversationId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+interface StoredMessageWithSimilarity extends StoredMessage {
+    similarity: number;
+}
+interface CreateMessageOptions {
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    files?: FileMetadata[];
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    vector?: number[];
+    embeddingModel?: string;
+    wasStopped?: boolean;
+    /** If set, indicates the message failed with this error */
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string;
+}
+interface CreateConversationOptions {
+    conversationId?: string;
+    title?: string;
+}
+interface UpdateMessageOptions {
+    content?: string;
+    model?: string;
+    files?: FileMetadata[];
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    vector?: number[];
+    embeddingModel?: string;
+    wasStopped?: boolean;
+    error?: string | null;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string | null;
+}
+interface BaseUseChatStorageOptions {
+    database: Database;
+    conversationId?: string;
+    autoCreateConversation?: boolean;
+    defaultConversationTitle?: string;
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    onData?: (chunk: string) => void;
+    onFinish?: (response: LlmapiResponseResponse) => void;
+    onError?: (error: Error) => void;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - required for migrating old encrypted data) */
+    signMessage?: (message: string) => Promise<string>;
+}
+interface BaseSendMessageWithStorageArgs {
+    content: string;
+    model?: string;
+    messages?: LlmapiMessage[];
+    includeHistory?: boolean;
+    maxHistoryMessages?: number;
+    files?: FileMetadata[];
+    onData?: (chunk: string) => void;
+    memoryContext?: string;
+    searchContext?: string;
+    sources?: SearchSource[];
+    thoughtProcess?: ActivityPhase[];
+    /**
+     * Whether to store the response server-side.
+     * When true, the response can be retrieved later using the response ID.
+     */
+    store?: boolean;
+    /**
+     * ID of a previous response to continue from.
+     * Enables multi-turn conversations without resending full history.
+     */
+    previousResponseId?: string;
+    /**
+     * Conversation ID for grouping related responses on the server.
+     */
+    serverConversation?: string;
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Array of tool definitions available to the model.
+     */
+    tools?: LlmapiTool[];
+    /**
+     * Controls which tool to use: "auto", "any", "none", "required", or a specific tool name.
+     */
+    toolChoice?: string;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort and summary output.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step.
+     */
+    thinking?: LlmapiThinkingOptions;
+    /**
+     * Per-request callback for thinking/reasoning chunks.
+     * Called with delta chunks as the model "thinks" through a problem.
+     */
+    onThinking?: (chunk: string) => void;
+}
+interface BaseSendMessageSuccessResult {
+    data: LlmapiResponseResponse;
+    error: null;
+    userMessage: StoredMessage;
+    assistantMessage: StoredMessage;
+}
+interface BaseSendMessageErrorResult {
+    data: null;
+    error: string;
+    userMessage?: StoredMessage;
+    assistantMessage?: undefined;
+}
+type BaseSendMessageWithStorageResult = BaseSendMessageSuccessResult | BaseSendMessageErrorResult;
+interface BaseUseChatStorageResult {
+    isLoading: boolean;
+    stop: () => void;
+    conversationId: string | null;
+    setConversationId: (id: string | null) => void;
+    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
+    getConversation: (id: string) => Promise<StoredConversation | null>;
+    getConversations: () => Promise<StoredConversation[]>;
+    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
+    getMessageCount: (conversationId: string) => Promise<number>;
+    clearMessages: (conversationId: string) => Promise<void>;
+}
+declare function generateConversationId(): string;
+
+declare class Message extends Model {
+    static table: string;
+    static associations: Associations;
+    messageId: number;
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    files?: FileMetadata[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    wasStopped?: boolean;
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    thinking?: string;
+}
+declare class Conversation extends Model {
+    static table: string;
+    static associations: Associations;
+    conversationId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+
+/**
+ * Options for useChatStorage hook (Expo version)
+ *
+ * Uses the base options without React-specific features (no local chat, no tools).
+ */
+type UseChatStorageOptions = BaseUseChatStorageOptions;
+/**
+ * Arguments for sendMessage with storage (Expo version)
+ *
+ * Uses the base arguments without React-specific features (no runTools, no headers).
+ */
+type SendMessageWithStorageArgs = BaseSendMessageWithStorageArgs;
+/**
+ * Result from sendMessage with storage (Expo version)
+ *
+ * Uses the base result without tool execution information.
+ */
+type SendMessageWithStorageResult = BaseSendMessageWithStorageResult;
+/**
+ * Result returned by useChatStorage hook (Expo version)
+ *
+ * Extends base result with Expo-specific sendMessage signature.
+ */
+interface UseChatStorageResult extends BaseUseChatStorageResult {
+    /** Send a message and automatically store it (Expo version) */
+    sendMessage: (args: SendMessageWithStorageArgs) => Promise<SendMessageWithStorageResult>;
+    /** Extract all links from assistant message content as SearchSource objects */
+    extractSourcesFromAssistantMessage: (assistantMessage: {
+        content: string;
+        sources?: SearchSource[];
+    }) => SearchSource[];
+    /** Update a message's fields (content, embedding, files, etc). Returns updated message or null if not found. */
+    updateMessage: (uniqueId: string, options: UpdateMessageOptions) => Promise<StoredMessage | null>;
+}
+/**
+ * A React hook that wraps useChat with automatic message persistence using WatermelonDB.
+ *
+ * **Expo/React Native version** - This is a lightweight version that only supports
+ * API-based chat completions. Local chat and client-side tools are not available.
+ *
+ * @param options - Configuration options
+ * @returns An object containing chat state, methods, and storage operations
+ *
+ * @example
+ * ```tsx
+ * import { Database } from '@nozbe/watermelondb';
+ * import { useChatStorage } from '@reverbia/sdk/expo';
+ *
+ * function ChatScreen({ database }: { database: Database }) {
+ *   const {
+ *     isLoading,
+ *     sendMessage,
+ *     conversationId,
+ *     getMessages,
+ *   } = useChatStorage({
+ *     database,
+ *     getToken: async () => getAuthToken(),
+ *     onData: (chunk) => setResponse((prev) => prev + chunk),
+ *   });
+ *
+ *   const handleSend = async () => {
+ *     const result = await sendMessage({
+ *       content: 'Hello!',
+ *       model: 'gpt-4o-mini',
+ *       includeHistory: true,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button onPress={handleSend} disabled={isLoading} title="Send" />
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useChatStorage(options: UseChatStorageOptions): UseChatStorageResult;
+
+type UseImageGenerationOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Callback function to be called when the generation finishes successfully.
+     */
+    onFinish?: (response: LlmapiImageGenerationResponse) => void;
+    /**
+     * Callback function to be called when an unexpected error is encountered.
+     */
+    onError?: (error: Error) => void;
+};
+type GenerateImageArgs = LlmapiImageGenerationRequest;
+type GenerateImageResult = {
+    data: LlmapiImageGenerationResponse;
+    error: null;
+} | {
+    data: null;
+    error: string;
+};
+type UseImageGenerationResult = {
+    isLoading: boolean;
+    generateImage: (args: GenerateImageArgs) => Promise<GenerateImageResult>;
+    stop: () => void;
+};
+/**
+ * React hook for generating images using the LLM API.
+ * @category Hooks
+ */
+declare function useImageGeneration(options?: UseImageGenerationOptions): UseImageGenerationResult;
+
+type UseModelsOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Optional filter for specific provider (e.g. "openai")
+     */
+    provider?: string;
+    /**
+     * Whether to fetch models automatically on mount (default: true)
+     */
+    autoFetch?: boolean;
+};
+type UseModelsResult = {
+    models: LlmapiModel[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * React hook for fetching available LLM models.
+ * Automatically fetches all available models.
+ * @category Hooks
+ */
+declare function useModels(options?: UseModelsOptions): UseModelsResult;
+
+declare const memoryStorageSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+
+declare class Memory extends Model {
+    static table: string;
+    type: MemoryType;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+    compositeKey: string;
+    uniqueKey: string;
+    createdAt: Date;
+    updatedAt: Date;
+    embedding?: number[];
+    embeddingModel?: string;
+    isDeleted: boolean;
+}
+
+/**
+ * Options for useMemoryStorage hook (Expo version)
+ *
+ * Uses the base options.
+ */
+type UseMemoryStorageOptions = BaseUseMemoryStorageOptions;
+/**
+ * Result returned by useMemoryStorage hook (Expo version)
+ *
+ * Uses the base result.
+ */
+type UseMemoryStorageResult = BaseUseMemoryStorageResult;
+/**
+ * A React hook that wraps useMemory with automatic memory persistence using WatermelonDB.
+ *
+ * **Expo/React Native version** - This is a lightweight version that only supports
+ * API-based embeddings. Local embeddings require web APIs not available in React Native.
+ *
+ * @param options - Configuration options
+ * @returns An object containing memory state, methods, and storage operations
+ *
+ * @example
+ * ```tsx
+ * import { Database } from '@nozbe/watermelondb';
+ * import { useMemoryStorage } from '@reverbia/sdk/expo';
+ *
+ * function MemoryScreen({ database }: { database: Database }) {
+ *   const {
+ *     memories,
+ *     extractMemoriesFromMessage,
+ *     searchMemories,
+ *   } = useMemoryStorage({
+ *     database,
+ *     getToken: async () => getAuthToken(),
+ *   });
+ *
+ *   const handleExtract = async () => {
+ *     await extractMemoriesFromMessage({
+ *       messages: [{ role: 'user', content: 'My name is John' }],
+ *     });
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button onPress={handleExtract} title="Extract" />
+ *       <Text>Memories: {memories.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useMemoryStorage(options: UseMemoryStorageOptions): UseMemoryStorageResult;
+
+/**
+ * Combined WatermelonDB schema for all SDK storage modules.
+ *
+ * This unified schema includes all tables needed by the SDK:
+ * - `history`: Chat message storage with embeddings and metadata
+ * - `conversations`: Conversation metadata and organization
+ * - `memories`: Persistent memory storage with semantic search
+ * - `modelPreferences`: User model preferences and settings
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@nozbe/watermelondb';
+ * import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs';
+ * import { sdkSchema, sdkMigrations, sdkModelClasses } from '@reverbia/sdk/react';
+ *
+ * const adapter = new LokiJSAdapter({
+ *   schema: sdkSchema,
+ *   migrations: sdkMigrations,
+ *   dbName: 'my-app-db',
+ *   useWebWorker: false,
+ *   useIncrementalIndexedDB: true,
+ * });
+ *
+ * const database = new Database({
+ *   adapter,
+ *   modelClasses: sdkModelClasses,
+ * });
+ * ```
+ */
+declare const sdkSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+/**
+ * Combined migrations for all SDK storage modules.
+ *
+ * These migrations handle database schema upgrades from any previous version
+ * to the current version. The SDK manages all migration logic internally,
+ * so consumer apps don't need to handle version arithmetic or migration merging.
+ *
+ * **Minimum supported version: v2**
+ * Migrations from v1 are not supported. Databases at v1 require a fresh install.
+ *
+ * Migration history:
+ * - v2 → v3: Added `was_stopped` column to history table
+ * - v3 → v4: Added `modelPreferences` table for settings storage
+ * - v4 → v5: Added `error` column to history table for error persistence
+ * - v5 → v6: Added `thought_process` column to history table for activity tracking
+ */
+declare const sdkMigrations: Readonly<{
+    validated: true;
+    minVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    maxVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    sortedMigrations: _nozbe_watermelondb_Schema_migrations.Migration[];
+}>;
+/**
+ * Model classes to register with the WatermelonDB database.
+ *
+ * Pass this array directly to the `modelClasses` option when creating
+ * your Database instance.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@nozbe/watermelondb';
+ * import { sdkSchema, sdkMigrations, sdkModelClasses } from '@reverbia/sdk/react';
+ *
+ * const database = new Database({
+ *   adapter,
+ *   modelClasses: sdkModelClasses,
+ * });
+ * ```
+ */
+declare const sdkModelClasses: Class<Model$1>[];
+
+export { Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, type FileMetadata, type MemoryItem, type MemoryType, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredMemory, Memory as StoredMemoryModel, type StoredMemoryWithSimilarity, type StoredMessage, type StoredMessageWithSimilarity, type UpdateMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseMemoryStorageOptions, type UseMemoryStorageResult, type UseModelsOptions, type UseModelsResult, chatStorageMigrations, chatStorageSchema, generateCompositeKey, generateConversationId, generateUniqueKey, memoryStorageSchema, sdkMigrations, sdkModelClasses, sdkSchema, useChat, useChatStorage, useImageGeneration, useMemoryStorage, useModels };