@anuma/sdk 1.0.0

package/dist/expo/index.d.ts

@@ -0,0 +1,2590 @@
+import { Database, Model, Collection } 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';
+import { DatabaseAdapter } from '@nozbe/watermelondb/adapters/type';
+
+type HandlersClaimDailyCreditsResponse = {
+    /**
+     * Credits awarded (1 credit = $0.01)
+     */
+    credits_awarded?: number;
+    message?: string;
+    /**
+     * ISO8601 timestamp when next claim is available
+     */
+    next_claim_at?: string;
+    success?: boolean;
+};
+type HandlersCreditBalanceResponse = {
+    /**
+     * Available credits (1 credit = $0.01)
+     */
+    available_credits?: number;
+    can_claim_daily?: boolean;
+    /**
+     * Whether enrolled on-chain
+     */
+    is_enrolled?: boolean;
+    last_claim_at?: string;
+    /**
+     * Total credits ever received (1 credit = $0.01)
+     */
+    lifetime_credits?: number;
+    next_claim_at?: string;
+    /**
+     * "basic" or "pro"
+     */
+    subscription_tier?: string;
+    wallet_address?: string;
+};
+type HandlersCreditPack = {
+    bonus_percent?: number;
+    credits?: number;
+    currency?: string;
+    pro_credits?: number;
+    unit_amount?: number;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiChatCompletionExtraFields = {
+    /**
+     * 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 "chat_completion"
+     */
+    request_type?: string;
+};
+type LlmapiChatCompletionResponse = {
+    /**
+     * Choices contains the completion choices
+     */
+    choices?: Array<LlmapiChoice>;
+    extra_fields?: LlmapiChatCompletionExtraFields;
+    /**
+     * ID is the completion ID
+     */
+    id?: string;
+    /**
+     * Messages contains the full conversation history when local tools need execution.
+     * This is populated when the model requests tools that are not MCP tools (local/client-side tools).
+     * The client should execute these tools and send a new request with this message history
+     * plus the tool results appended.
+     */
+    messages?: Array<LlmapiMessage>;
+    /**
+     * Model is the model used
+     */
+    model?: string;
+    /**
+     * ToolCallEvents is an array of tool call events.
+     */
+    tool_call_events?: Array<LlmapiToolCallEvent>;
+    /**
+     * ToolsChecksum is the checksum of the tool schemas used by the AI Portal.
+     */
+    tools_checksum?: string;
+    usage?: LlmapiChatCompletionUsage;
+};
+type LlmapiChatCompletionTool = {
+    [key: string]: unknown;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiChatCompletionUsage = {
+    /**
+     * CompletionTokens is the number of tokens in the completion
+     */
+    completion_tokens?: number;
+    /**
+     * CostMicroUSD is the cost of this completion in micro-dollars (USD × 1,000,000)
+     */
+    cost_micro_usd?: number;
+    /**
+     * CreditsUsed is the number of credits consumed by this completion (ceiling of cost / MicroUSDPerCredit)
+     */
+    credits_used?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+type LlmapiChoice = {
+    /**
+     * FinishReason indicates why the completion stopped
+     */
+    finish_reason?: string;
+    /**
+     * Index is the choice index
+     */
+    index?: number;
+    message?: LlmapiMessage;
+};
+type LlmapiMcpTool = {
+    /**
+     * Description is the description of the tool
+     */
+    description?: string;
+    /**
+     * InputSchema is the JSON schema describing the tool's input
+     */
+    input_schema?: unknown;
+    /**
+     * Name is the name of the tool
+     */
+    name?: string;
+};
+/**
+ * Message is the generated message
+ */
+type LlmapiMessage = {
+    /**
+     * Content is the message content
+     */
+    content?: Array<LlmapiMessageContentPart>;
+    role?: LlmapiRole;
+    /**
+     * ToolCallID is the ID of the tool call this message is responding to (only for tool role)
+     */
+    tool_call_id?: string;
+    /**
+     * ToolCalls contains tool/function calls made by the assistant (only for assistant role)
+     */
+    tool_calls?: Array<LlmapiToolCall>;
+    /**
+     * Type is the message type (for Responses API: "message")
+     */
+    type?: string;
+};
+/**
+ * File is used when Type=input_file (for Responses API)
+ */
+type LlmapiMessageContentFile = {
+    /**
+     * FileData is the base64-encoded file content
+     */
+    file_data?: string;
+    /**
+     * FileID is the ID of an uploaded file
+     */
+    file_id?: string;
+    /**
+     * FileURL is the URL to the file
+     */
+    file_url?: string;
+    /**
+     * Filename is the name of the file
+     */
+    filename?: string;
+};
+/**
+ * ImageURL is used when Type=image_url or Type=input_image
+ */
+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 = {
+    file?: LlmapiMessageContentFile;
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text or Type=input_text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text`, `image_url`, or `input_file`)
+     */
+    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 and mcp_call types
+     */
+    arguments?: string;
+    /**
+     * CallID is the call ID for function_call and mcp_call types
+     */
+    call_id?: string;
+    /**
+     * Content is the content array for message and reasoning types
+     */
+    content?: Array<LlmapiResponseOutputContent>;
+    /**
+     * Error is the MCP error message for mcp_call types
+     */
+    error?: string;
+    /**
+     * ID is the unique identifier for this output item
+     */
+    id?: string;
+    /**
+     * Name is the function name for function_call and mcp_call types
+     */
+    name?: string;
+    /**
+     * Output is the MCP tool output for mcp_call types
+     */
+    output?: string;
+    /**
+     * Role is the role for message types (e.g., "assistant")
+     */
+    role?: string;
+    /**
+     * ServerLabel is the MCP server label for mcp_call and mcp_list_tools types
+     */
+    server_label?: 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>;
+    /**
+     * Tools is the list of available tools for mcp_list_tools types
+     */
+    tools?: Array<LlmapiMcpTool>;
+    /**
+     * Type is the output item type (e.g., "message", "function_call", "reasoning", "mcp_call")
+     */
+    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;
+    /**
+     * Messages contains the full conversation history when local tools need execution.
+     * This is populated when the model requests tools that are not MCP tools (local/client-side tools).
+     * The client should execute these tools and send a new request with this message history
+     * plus the tool results appended.
+     */
+    messages?: Array<LlmapiMessage>;
+    /**
+     * 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>;
+    /**
+     * ToolCallEvents is an array of tool call events.
+     */
+    tool_call_events?: Array<LlmapiToolCallEvent>;
+    /**
+     * ToolsChecksum is the checksum of the tool schemas used by the AI Portal.
+     */
+    tools_checksum?: string;
+    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;
+    /**
+     * CreditsUsed is the number of credits consumed by this response
+     */
+    credits_used?: 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, tool)
+ */
+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 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;
+};
+type LlmapiToolCallEvent = {
+    arguments?: string;
+    id?: string;
+    name?: string;
+    output?: 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;
+};
+
+/**
+ * Server tool call event emitted during streaming
+ */
+type ServerToolCallEvent = {
+    /** Tool name (e.g., "BraveSearchMCP_brave_web_search") */
+    name: string;
+    /** Status: "started" when tool begins, "completed" when done */
+    status: "started" | "completed";
+    /** Arguments passed to the tool (JSON string) */
+    arguments?: string;
+};
+
+/**
+ * API type selector for useChat
+ * - "responses": OpenAI Responses API (supports thinking, reasoning, conversations)
+ * - "completions": OpenAI Chat Completions API (wider model compatibility)
+ */
+type ApiType = "responses" | "completions";
+/**
+ * Union type for API responses - raw pass-through from server.
+ * Responses API returns LlmapiResponseResponse (with output[]).
+ * Completions API returns LlmapiChatCompletionResponse (with choices[]).
+ */
+type ApiResponse = LlmapiResponseResponse | LlmapiChatCompletionResponse;
+
+/**
+ * Configuration for stream output smoothing.
+ *
+ * Controls the adaptive speed ramp that meters out streaming text
+ * at a consistent pace regardless of how fast the model produces tokens.
+ */
+type StreamSmoothingConfig = {
+    /** Whether smoothing is enabled. Default: true */
+    enabled: boolean;
+    /** Minimum chars/sec at the start of streaming. Default: 60 */
+    minSpeed?: number;
+    /** Maximum chars/sec after ramp completes. Default: 600 */
+    maxSpeed?: number;
+    /** Duration in ms to ramp from minSpeed to maxSpeed. Default: 4000 */
+    rampDuration?: number;
+};
+
+/**
+ * Tool executor function type
+ */
+type ToolExecutor = (args: Record<string, unknown>) => Promise<unknown> | unknown;
+/**
+ * Tool configuration with optional executor
+ */
+type ToolConfig = LlmapiChatCompletionTool & {
+    /**
+     * Function to execute when the tool is called.
+     * If provided, the tool will be executed automatically when the LLM calls it.
+     * If not provided, an onToolCall event will be emitted instead.
+     */
+    executor?: ToolExecutor;
+    /**
+     * Whether to execute this tool automatically when called by the LLM.
+     * Default: true if executor is provided, false otherwise.
+     */
+    autoExecute?: boolean;
+};
+/**
+ * Responses API options that can be passed to sendMessage
+ */
+type ResponsesApiOptions = {
+    /**
+     * 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.
+     * Can include executor functions for automatic tool execution.
+     */
+    tools?: Array<LlmapiChatCompletionTool | ToolConfig>;
+    /**
+     * 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.
+ * Returns raw API response - either Responses API or Completions API format.
+ */
+type BaseSendMessageResult = {
+    data: ApiResponse;
+    error: null;
+} | {
+    data: null;
+    error: string;
+};
+/**
+ * Base options for useChat hook
+ * @inline
+ */
+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.
+     * Receives raw API response - either Responses API or Completions API format.
+     */
+    onFinish?: (response: ApiResponse) => 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;
+    /**
+     * Callback function to be called when a tool call is requested by the LLM.
+     * This is called for tools that don't have an executor or have autoExecute=false.
+     * The app should execute the tool and send the result back.
+     *
+     * @param toolCall - The tool call requested by the LLM
+     */
+    onToolCall?: (toolCall: LlmapiToolCall) => void;
+    /**
+     * Callback function to be called when a server-side tool (MCP) is invoked during streaming.
+     * Use this to show activity indicators like "Searching..." in the UI.
+     *
+     * @param toolCall - Info about the server tool being called
+     * @param toolCall.name - The tool name (e.g., "BraveSearchMCP_brave_web_search")
+     * @param toolCall.status - "started" when tool begins, "completed" when done
+     * @param toolCall.arguments - The arguments passed to the tool (JSON string)
+     */
+    onServerToolCall?: (toolCall: ServerToolCallEvent) => void;
+    /**
+     * Controls adaptive output smoothing for streaming responses.
+     * Fast models can return text faster than is comfortable to read — smoothing
+     * buffers incoming chunks and releases them at a consistent, adaptive pace.
+     *
+     * - `true` or omitted: enabled with defaults (200→400 chars/sec over 3s)
+     * - `false`: disabled, callbacks fire immediately with raw chunks
+     * - `StreamSmoothingConfig`: custom speed/ramp configuration
+     *
+     * @default true
+     */
+    smoothing?: StreamSmoothingConfig | boolean;
+};
+/**
+ * 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;
+    /**
+     * Memory context to inject as a system message.
+     * This is typically formatted memories from useMemoryStorage.
+     */
+    memoryContext?: string;
+    /**
+     * Search context to inject as a system message.
+     * This is typically formatted search results from useSearch.
+     */
+    searchContext?: string;
+    /**
+     * Override the API type for this request only.
+     * Useful when different models need different APIs.
+     * @default Uses the hook-level apiType or "responses"
+     */
+    apiType?: ApiType;
+};
+type SendMessageResult = BaseSendMessageResult;
+/**
+ * @inline
+ */
+interface UseChatOptions extends BaseUseChatOptions {
+    /**
+     * Which API endpoint to use. Default: "responses"
+     * - "responses": OpenAI Responses API (supports thinking, reasoning, conversations)
+     * - "completions": OpenAI Chat Completions API (wider model compatibility)
+     */
+    apiType?: ApiType;
+}
+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[];
+}
+
+/**
+ * Register a callback that fires when an encryption key becomes available for an address.
+ * If the key is already available, the callback fires immediately.
+ * @returns Unsubscribe function
+ */
+declare function onKeyAvailable(address: string, callback: () => void): () => void;
+/**
+ * Clears the encryption key for a wallet address from memory
+ * @param address - The wallet address
+ */
+declare function clearEncryptionKey(address: string): void;
+/**
+ * Clears all encryption keys from memory
+ */
+declare function clearAllEncryptionKeys(): void;
+/**
+ * Checks if an encryption key exists in memory for the given wallet address
+ */
+declare function hasEncryptionKey(address: string): boolean;
+/**
+ * Options for signing messages.
+ */
+interface SignMessageOptions {
+    /** Whether to show wallet UI during signing. Default: true */
+    showWalletUIs?: boolean;
+}
+/**
+ * Type for the signMessage function that client must provide.
+ * This is typically from Privy's useSignMessage hook.
+ */
+type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
+/**
+ * Type for embedded wallet signer function that enables silent signing.
+ * For Privy embedded wallets, this can sign programmatically without user interaction
+ * when configured correctly in the Privy dashboard.
+ */
+type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
+/**
+ * Requests the user to sign a message to generate an encryption key.
+ * If a key already exists in memory for the given wallet, resolves immediately.
+ *
+ * Note: Keys are stored in memory only and do not persist across page reloads.
+ * This is a security feature - users must sign once per session to derive their key.
+ *
+ * @param walletAddress - The wallet address to generate the key for
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @returns Promise that resolves when the key is available
+ */
+declare function requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<void>;
+/**
+ * Result returned by the useEncryption hook.
+ * @category Hooks
+ */
+interface UseEncryptionResult {
+    /** Request and generate an encryption key for a wallet address */
+    requestEncryptionKey: (walletAddress: string) => Promise<void>;
+    /** Request and generate an ECDH key pair for a wallet address */
+    requestKeyPair: (walletAddress: string) => Promise<void>;
+    /** Export the public key for a wallet address as base64-encoded SPKI */
+    exportPublicKey: (walletAddress: string) => Promise<string>;
+    /** Check if a key pair exists in memory for a wallet address */
+    hasKeyPair: (walletAddress: string) => boolean;
+    /** Clear the key pair for a wallet address from memory */
+    clearKeyPair: (walletAddress: string) => void;
+}
+/**
+ * Hook that provides encryption key management for securing local data.
+ *
+ * This hook helps you encrypt and decrypt data using a key derived from a wallet
+ * signature. It requires `@privy-io/react-auth` for wallet authentication. Keys are
+ * stored in memory only and do not persist across page reloads for security.
+ *
+ * ## How it works
+ *
+ * 1. User signs a message with their wallet
+ * 2. The signature is used to deterministically derive an encryption key
+ * 3. The key is stored in memory (not localStorage) for the session
+ * 4. Data can be encrypted/decrypted using this key
+ * 5. On page reload, user must sign again to derive the key
+ *
+ * ## Security Features
+ *
+ * - **In-memory only**: Keys never touch disk or localStorage
+ * - **Deterministic**: Same wallet + signature always generates same key
+ * - **Session-scoped**: Keys cleared on page reload
+ * - **XSS-resistant**: Keys not accessible after page reload
+ *
+ * ## Embedded Wallet Support
+ *
+ * For Privy embedded wallets, you can provide an `embeddedWalletSigner` function
+ * to enable silent signing without user confirmation modals. This is useful for
+ * deterministic key generation that should happen automatically.
+ *
+ * @param signMessage - Function to sign a message (from Privy's useSignMessage hook)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @returns Functions to request encryption keys and manage key pairs
+ *
+ * @example
+ * ```tsx
+ * import { usePrivy, useWallets } from "@privy-io/react-auth";
+ * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
+ *
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { wallets } = useWallets();
+ *   const embeddedWallet = wallets.find(w => w.walletClientType === 'privy');
+ *
+ *   // Create silent signer for embedded wallets
+ *   const embeddedSigner = useCallback(async (message: string) => {
+ *     if (embeddedWallet) {
+ *       const { signature } = await embeddedWallet.signMessage({ message });
+ *       return signature;
+ *     }
+ *     throw new Error('No embedded wallet');
+ *   }, [embeddedWallet]);
+ *
+ *   const { requestEncryptionKey } = useEncryption(signMessage, embeddedSigner);
+ *
+ *   // Request encryption key when user is authenticated
+ *   useEffect(() => {
+ *     if (user?.wallet?.address) {
+ *       // This will use silent signing for embedded wallets
+ *       await requestEncryptionKey(user.wallet.address);
+ *     }
+ *   }, [user]);
+ *
+ *   // Encrypt data
+ *   const saveSecret = async (text: string) => {
+ *     const encrypted = await encryptData(text, user.wallet.address);
+ *     localStorage.setItem("mySecret", encrypted);
+ *   };
+ *
+ *   // Decrypt data
+ *   const loadSecret = async () => {
+ *     const encrypted = localStorage.getItem("mySecret");
+ *     if (encrypted) {
+ *       const decrypted = await decryptData(encrypted, user.wallet.address);
+ *       console.log(decrypted);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => saveSecret("my secret data")}>Encrypt & Save</button>
+ *       <button onClick={loadSecret}>Load & Decrypt</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Standard usage with external wallets (shows confirmation modal)
+ * import { usePrivy } from "@privy-io/react-auth";
+ * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
+ *
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { requestEncryptionKey } = useEncryption(signMessage);
+ *
+ *   // Request encryption key when user is authenticated
+ *   useEffect(() => {
+ *     if (user?.wallet?.address) {
+ *       // This will prompt user to sign if key doesn't exist
+ *       await requestEncryptionKey(user.wallet.address);
+ *     }
+ *   }, [user]);
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // ECDH key pair generation for end-to-end encryption
+ * import { usePrivy } from "@privy-io/react-auth";
+ * import { useEncryption } from "@anuma/sdk/react";
+ *
+ * function E2EEComponent() {
+ *   const { signMessage } = usePrivy();
+ *   const { requestKeyPair, exportPublicKey } = useEncryption(signMessage);
+ *
+ *   const setupEncryption = async (walletAddress: string) => {
+ *     // Generate deterministic ECDH key pair from wallet signature
+ *     await requestKeyPair(walletAddress);
+ *
+ *     // Export public key to share with others
+ *     const publicKey = await exportPublicKey(walletAddress);
+ *     console.log("Share this public key:", publicKey);
+ *   };
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useEncryption(signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): UseEncryptionResult;
+
+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;
+}
+/**
+ * @inline
+ */
+interface BaseUseMemoryStorageOptions {
+    database: Database;
+    completionsModel?: string;
+    embeddingModel?: string | null;
+    generateEmbeddings?: boolean;
+    onFactsExtracted?: (facts: MemoryExtractionResult) => void;
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    walletAddress?: string;
+    signMessage?: SignMessageFn;
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+}
+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;
+
+/**
+ * Server-side tools caching module
+ *
+ * Fetches and caches tools from /api/v1/tools endpoint
+ * with configurable expiration and localStorage persistence.
+ */
+
+/** Tool parameters schema */
+interface ToolParameters {
+    properties: Record<string, unknown>;
+    required: string[];
+    type: "object";
+}
+/** Current API response format (description and parameters at top level) */
+interface ServerToolsResponseItemCurrent {
+    description: string;
+    name: string;
+    parameters: ToolParameters;
+}
+/** New API response format with schema wrapper */
+interface ServerToolsResponseItemNew {
+    name: string;
+    schema: {
+        name: string;
+        description: string;
+        parameters: ToolParameters;
+    };
+    cost?: number;
+    embedding?: number[];
+}
+/** Response item can be either format */
+type ServerToolsResponseItem = ServerToolsResponseItemCurrent | ServerToolsResponseItemNew;
+/** Tools object mapping tool names to their definitions */
+type ServerToolsMap = {
+    [toolName: string]: ServerToolsResponseItem;
+};
+/**
+ * Response format from /api/v1/tools endpoint.
+ * New format includes checksum and tools wrapper.
+ * Legacy format is just the tools map directly.
+ */
+type ServerToolsResponse = {
+    checksum: string;
+    tools: ServerToolsMap;
+} | ServerToolsMap;
+/**
+ * Server tool definition with parameters field.
+ * This is the neutral format stored in cache.
+ * Strategies transform this to the correct API format.
+ */
+interface ServerTool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+    /** Optional embedding vector for semantic matching */
+    embedding?: number[];
+}
+/**
+ * Cached tools structure stored in localStorage
+ */
+interface CachedServerTools {
+    tools: ServerTool[];
+    timestamp: number;
+    version: string;
+    /** Checksum from the server for cache invalidation */
+    checksum?: string;
+}
+/**
+ * Options for fetching server tools
+ */
+interface ServerToolsOptions {
+    /** Base URL for the API (defaults to BASE_URL from clientConfig) */
+    baseUrl?: string;
+    /** Cache expiration time in milliseconds (default: 5 minutes) */
+    cacheExpirationMs?: number;
+    /** Force refresh even if cache is valid */
+    forceRefresh?: boolean;
+    /** Authentication token getter */
+    getToken: () => Promise<string | null>;
+}
+/** Default cache expiration: 1 day */
+declare const DEFAULT_CACHE_EXPIRATION_MS: number;
+/**
+ * Get cached tools from localStorage
+ */
+declare function getCachedServerTools(): CachedServerTools | null;
+/**
+ * Clear the server tools cache
+ */
+declare function clearServerToolsCache(): void;
+/**
+ * Get server tools with caching support.
+ *
+ * Flow:
+ * 1. Check localStorage cache
+ * 2. If cache valid and not force refresh, return cached tools
+ * 3. Otherwise, fetch from API, cache, and return
+ * 4. On fetch failure, return cached tools if available (stale-while-error)
+ */
+declare function getServerTools(options: ServerToolsOptions): Promise<ServerTool[]>;
+
+/**
+ * Function type for dynamic server tools filtering based on prompt embeddings.
+ * Receives the prompt embedding(s) and all available tools, returns tool names to include.
+ *
+ * @param embeddings - Single embedding or array of embeddings (for chunked messages)
+ * @param tools - All available server tools with embeddings
+ * @returns Array of tool names to include
+ */
+type ServerToolsFilterFn = (embeddings: number[] | number[][], tools: ServerTool[]) => string[];
+/**
+ * Server tools filter: static list of names or dynamic function.
+ * - string[]: Static list of tool names to include
+ * - ServerToolsFilterFn: Dynamic filter based on prompt embeddings
+ */
+type ServerToolsFilter = string[] | ServerToolsFilterFn;
+type ChatRole = "user" | "assistant" | "system";
+/**
+ * Metadata for files attached to messages.
+ *
+ * Note the distinction between `url` and `sourceUrl`:
+ * - `url`: Content URL that gets sent to the AI as part of the message (e.g., data URIs for user uploads)
+ * - `sourceUrl`: Original external URL for locally-cached files (for lookup only, never sent to AI)
+ */
+interface FileMetadata {
+    /** Unique identifier for the file (used as OPFS key for cached files) */
+    id: string;
+    /** Display name of the file */
+    name: string;
+    /** MIME type (e.g., "image/png") */
+    type: string;
+    /** File size in bytes */
+    size: number;
+    /**
+     * Content URL to include when sending this message to the AI.
+     * When present, this URL is added as an `image_url` content part.
+     * Typically used for user-uploaded files (data URIs) that should be sent with the message.
+     *
+     * NOT used for MCP-cached files - those use `sourceUrl` for lookup and render from OPFS.
+     */
+    url?: string;
+    /**
+     * Original external URL for files downloaded and cached locally (e.g., from MCP R2).
+     * Used purely for URL→OPFS mapping to enable fallback when the source returns 404.
+     *
+     * This is metadata for local lookup only - it is NOT sent to the AI or rendered directly.
+     * The file content is served from OPFS using the `id` field.
+     */
+    sourceUrl?: string;
+}
+interface ChatCompletionUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    costMicroUsd?: number;
+    creditsUsed?: 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;
+    /** @deprecated Use fileIds with media table instead */
+    files?: FileMetadata[];
+    /** Array of media_id references for direct lookup in media table */
+    fileIds?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    /** Chunks of this message with individual embeddings for fine-grained search */
+    chunks?: MessageChunk[];
+    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;
+    /** Optional project ID this conversation belongs to */
+    projectId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+interface StoredMessageWithSimilarity extends StoredMessage {
+    similarity: number;
+}
+/**
+ * A chunk of a message with its own embedding for fine-grained search
+ */
+interface MessageChunk {
+    /** The chunk text */
+    text: string;
+    /** Embedding vector for this chunk */
+    vector: number[];
+    /** Character offset where this chunk starts in the original message */
+    startOffset: number;
+    /** Character offset where this chunk ends in the original message */
+    endOffset: number;
+}
+interface CreateMessageOptions {
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    /** @deprecated Use fileIds with media table instead */
+    files?: FileMetadata[];
+    /** Array of media_id references for direct lookup in media table */
+    fileIds?: string[];
+    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;
+    /** Optional project ID to associate this conversation with */
+    projectId?: string;
+}
+/**
+ * Base options for useChatStorage hook
+ * @inline
+ */
+interface BaseUseChatStorageOptions {
+    /** WatermelonDB database instance for storing conversations and messages */
+    database: Database;
+    /** ID of an existing conversation to load and continue */
+    conversationId?: string;
+    /** Automatically create a new conversation if none is set (default: true) */
+    autoCreateConversation?: boolean;
+    /** Title for auto-created conversations (default: "New conversation") */
+    defaultConversationTitle?: string;
+    /** Function to retrieve the auth token for API requests */
+    getToken?: () => Promise<string | null>;
+    /** Base URL for the chat API endpoint */
+    baseUrl?: string;
+    /** Callback invoked with each streamed response chunk */
+    onData?: (chunk: string) => void;
+    /** Callback invoked when thinking/reasoning content is received (from `<think>` tags or API reasoning) */
+    onThinking?: (chunk: string) => void;
+    /** Callback invoked when the response completes successfully */
+    onFinish?: (response: LlmapiResponseResponse) => void;
+    /** Callback invoked when an error occurs during the request */
+    onError?: (error: Error) => void;
+    /**
+     * Callback invoked when a server-side tool (MCP) is called during streaming.
+     * Use this to show activity indicators like "Searching..." in the UI.
+     */
+    onServerToolCall?: (toolCall: ServerToolCallEvent) => void;
+    /**
+     * File preprocessors to use for automatic text extraction.
+     * - undefined (default): Use all built-in processors (PDF, Excel, Word)
+     * - null or []: Disable preprocessing
+     * - FileProcessor[]: Use specific processors
+     */
+    fileProcessors?: any[] | null;
+    /**
+     * Options for file preprocessing behavior
+     */
+    fileProcessingOptions?: {
+        /** Whether to keep original file attachments (default: true) */
+        keepOriginalFiles?: boolean;
+        /** Max file size to process in bytes (default: 10MB) */
+        maxFileSizeBytes?: number;
+        /** Callback for progress updates */
+        onProgress?: (current: number, total: number, fileName: string) => void;
+        /** Callback for errors (non-fatal) */
+        onError?: (fileName: string, error: Error) => void;
+    };
+    /**
+     * Configuration for server-side tools fetching and caching.
+     * Server tools are fetched from /api/v1/tools and cached in localStorage.
+     */
+    serverTools?: {
+        /** Cache expiration time in milliseconds (default: 86400000 = 1 day) */
+        cacheExpirationMs?: number;
+    };
+    /**
+     * Automatically generate embeddings for messages after saving.
+     * Enables semantic search over past conversations via searchMessages().
+     * @default true
+     */
+    autoEmbedMessages?: boolean;
+    /**
+     * Embedding model to use when autoEmbedMessages is enabled.
+     * @default DEFAULT_API_EMBEDDING_MODEL
+     */
+    embeddingModel?: string;
+    /**
+     * Minimum content length required to generate embeddings.
+     * Messages shorter than this are skipped as they provide limited semantic value.
+     * @default 10
+     */
+    minContentLength?: number;
+}
+/**
+ * Base arguments for sending a message with automatic storage.
+ *
+ * These arguments control both the AI request and how the message
+ * is persisted to the local database.
+ * @inline
+ */
+interface BaseSendMessageWithStorageArgs {
+    /**
+     * The message array to send to the AI.
+     *
+     * Uses the modern array format that supports multimodal content (text, images, files).
+     * The last user message in this array will be extracted and stored in the database.
+     *
+     * When `includeHistory` is true (default), conversation history is prepended.
+     * When `includeHistory` is false, only these messages are sent.
+     *
+     * @example
+     * ```ts
+     * // Simple usage
+     * sendMessage({
+     *   messages: [
+     *     { role: "user", content: [{ type: "text", text: "Hello!" }] }
+     *   ]
+     * })
+     *
+     * // With system prompt and history disabled
+     * sendMessage({
+     *   messages: [
+     *     { role: "system", content: [{ type: "text", text: "You are helpful" }] },
+     *     { role: "user", content: [{ type: "text", text: "Question" }] },
+     *   ],
+     *   includeHistory: false
+     * })
+     *
+     * // With images
+     * sendMessage({
+     *   messages: [
+     *     { role: "user", content: [
+     *       { type: "text", text: "What's in this image?" },
+     *       { type: "image_url", image_url: { url: "data:image/png;base64,..." } }
+     *     ]}
+     *   ]
+     * })
+     * ```
+     */
+    messages: LlmapiMessage[];
+    /**
+     * The model identifier to use for this request (e.g., "gpt-4o", "claude-sonnet-4-20250514").
+     * If not specified, uses the default model configured on the server.
+     */
+    model?: string;
+    /**
+     * Skip all storage operations (conversation, messages, embeddings, media).
+     * Use this for one-off tasks like title generation where you don't want
+     * to pollute the database with utility messages.
+     *
+     * When true:
+     * - No conversation is created or required
+     * - Messages are not stored in the database
+     * - No embeddings are generated
+     * - No media/files are processed for storage
+     * - Result will not include userMessage or assistantMessage
+     *
+     * @default false
+     *
+     * @example
+     * ```ts
+     * // Generate a title without storing anything
+     * const { data } = await sendMessage({
+     *   messages: [{ role: "user", content: [{ type: "text", text: "Generate a title for: ..." }] }],
+     *   skipStorage: true,
+     *   includeHistory: false,
+     * });
+     * ```
+     */
+    skipStorage?: boolean;
+    /**
+     * Whether to automatically include previous messages from the conversation as context.
+     * When true, fetches stored messages and prepends them to the request.
+     * Ignored if `messages` is provided.
+     * @default true
+     */
+    includeHistory?: boolean;
+    /**
+     * Maximum number of historical messages to include when `includeHistory` is true.
+     * Only the most recent N messages are included to manage context window size.
+     * @default 50
+     */
+    maxHistoryMessages?: number;
+    /**
+     * File attachments to include with the message (images, documents, etc.).
+     * Files with image MIME types and URLs are sent as image content parts.
+     * File metadata is stored with the message (URLs are stripped if they're data URIs).
+     */
+    files?: FileMetadata[];
+    /**
+     * Per-request callback invoked with each streamed response chunk.
+     * Overrides the hook-level `onData` callback for this request only.
+     * Use this to update UI as the response streams in.
+     */
+    onData?: (chunk: string) => void;
+    /**
+     * Additional context from memory/RAG system to include in the request.
+     * Typically contains retrieved relevant information from past conversations.
+     */
+    memoryContext?: string;
+    /**
+     * Additional context from search results to include in the request.
+     * Typically contains relevant information from web or document searches.
+     */
+    searchContext?: string;
+    /**
+     * Additional context from preprocessed file attachments.
+     * Contains extracted text from Excel, Word, PDF, and other document files.
+     * Injected as a system message so it's available throughout the conversation.
+     */
+    fileContext?: string;
+    /**
+     * Search sources to attach to the stored message for citation/reference.
+     * Note: Sources are also automatically extracted from tool_call_events in the response.
+     */
+    sources?: SearchSource[];
+    /**
+     * Activity phases for tracking the request lifecycle in the UI.
+     * Each phase represents a step like "Searching", "Thinking", "Generating".
+     * The final phase is automatically marked as completed when stored.
+     *
+     * Note: If you need activity phases that are added during streaming (e.g., server tool calls),
+     * use `getThoughtProcess` callback instead, which captures phases AFTER streaming completes.
+     */
+    thoughtProcess?: ActivityPhase[];
+    /**
+     * Callback to get activity phases AFTER streaming completes.
+     * Use this instead of `thoughtProcess` when phases are added dynamically during streaming
+     * (e.g., via server tool call events like "Searching...", "Generating image...").
+     *
+     * If both `thoughtProcess` and `getThoughtProcess` are provided, `getThoughtProcess` takes precedence.
+     */
+    getThoughtProcess?: () => ActivityPhase[];
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     * Lower values make output more deterministic, higher values more creative.
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     * Use this to limit response length and control costs.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Client-side tools with optional executors.
+     * These tools run in the browser/app and can have JavaScript executor functions.
+     */
+    clientTools?: LlmapiChatCompletionTool[];
+    /**
+     * Server-side tools to include from /api/v1/tools.
+     * - undefined: Include all server-side tools (default)
+     * - string[]: Include only tools with these names
+     * - []: Include no server-side tools
+     * - function: Dynamic filter that receives prompt embedding(s) and all tools,
+     *   returns tool names to include. Useful for semantic tool matching.
+     *
+     * @example
+     * // Include only specific server tools
+     * serverTools: ["generate_cloud_image", "perplexity_search"]
+     *
+     * // Disable server tools for this request
+     * serverTools: []
+     *
+     * // Semantic tool matching based on prompt
+     * serverTools: (embeddings, tools) => {
+     *   const matches = findMatchingTools(embeddings, tools, { limit: 5 });
+     *   return matches.map(m => m.tool.name);
+     * }
+     */
+    serverTools?: ServerToolsFilter;
+    /**
+     * Controls which tool the model should use:
+     * - "auto": Model decides whether to use a tool (default)
+     * - "any": Model must use one of the provided tools
+     * - "none": Model cannot use any tools
+     * - "required": Model must use a tool
+     * - Specific tool name: Model must use that specific tool
+     */
+    toolChoice?: string;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort level and whether to include reasoning summary.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step
+     * before generating the final response.
+     */
+    thinking?: LlmapiThinkingOptions;
+    /**
+     * Per-request callback for thinking/reasoning chunks.
+     * Called with delta chunks as the model "thinks" through a problem.
+     * Use this to display thinking progress in the UI.
+     */
+    onThinking?: (chunk: string) => void;
+}
+interface BaseSendMessageSuccessResult {
+    data: LlmapiResponseResponse;
+    error: null;
+    userMessage: StoredMessage;
+    assistantMessage: StoredMessage;
+}
+interface BaseSendMessageSkippedResult {
+    data: LlmapiResponseResponse;
+    error: null;
+    userMessage?: undefined;
+    assistantMessage?: undefined;
+    /** Indicates this was a skipStorage request - no messages were persisted */
+    skipped: true;
+}
+interface BaseSendMessageErrorResult {
+    data: null;
+    error: string;
+    userMessage?: StoredMessage;
+    assistantMessage?: undefined;
+}
+type BaseSendMessageWithStorageResult = BaseSendMessageSuccessResult | BaseSendMessageSkippedResult | 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[]>;
+}
+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;
+    /** @deprecated Use fileIds with media table instead */
+    files?: FileMetadata[];
+    /** Array of media_id references for direct lookup */
+    fileIds?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    chunks?: MessageChunk[];
+    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;
+    projectId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+
+interface StorageOperationsContext {
+    database: Database;
+    messagesCollection: Collection<Message>;
+    conversationsCollection: Collection<Conversation>;
+    /** Wallet address for encryption (optional - when present, enables field-level encryption) */
+    walletAddress?: string;
+    /** Function to sign a message for encryption key derivation */
+    signMessage?: SignMessageFn;
+    /** Function for silent signing with embedded wallets */
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+}
+
+/**
+ * Memory Retrieval Types
+ *
+ * Types for the memory retrieval feature that allows semantic search
+ * across past conversation messages.
+ */
+
+/**
+ * Options for memory retrieval search
+ */
+interface MemoryRetrievalSearchOptions {
+    /** Maximum number of results to return (default: 8) */
+    limit?: number;
+    /** Alias for limit - number of chunks to return (default: 8) */
+    topK?: number;
+    /** Minimum similarity threshold 0-1 (default: 0.3) */
+    minSimilarity?: number;
+    /** Include assistant messages in results (default: false) */
+    includeAssistant?: boolean;
+    /** Filter to a specific conversation */
+    conversationId?: string;
+    /** Exclude messages from this conversation (e.g., the current conversation) */
+    excludeConversationId?: string;
+    /** Inclusive start date filter (currently disabled) */
+    startDate?: string;
+    /** Inclusive end date filter (currently disabled) */
+    endDate?: string;
+    /** Sort order for results: "similarity" (most relevant first) or "chronological" (oldest first). Default: "similarity" */
+    sortBy?: "similarity" | "chronological";
+}
+/**
+ * A retrieved message with similarity score
+ */
+interface MemoryRetrievalResult {
+    /** Message content */
+    content: string;
+    /** Role of the message sender */
+    role: "user" | "assistant";
+    /** Conversation this message belongs to */
+    conversationId: string;
+    /** Cosine similarity score (0-1) */
+    similarity: number;
+    /** When the message was created */
+    createdAt: Date;
+    /** Unique message ID */
+    uniqueId: string;
+}
+/**
+ * Options for embedding generation
+ *
+ * Supports two auth methods:
+ * - `getToken`: For Privy identity tokens (uses Authorization: Bearer header)
+ * - `apiKey`: For direct API keys (uses X-API-Key header)
+ *
+ * At least one of `getToken` or `apiKey` must be provided.
+ */
+interface EmbeddingOptions {
+    /** Function to get auth token (e.g., Privy's getIdentityToken). Uses Authorization: Bearer header. */
+    getToken?: () => Promise<string | null>;
+    /** Direct API key for server-side usage. Uses X-API-Key header. */
+    apiKey?: string;
+    /** Base URL for the API */
+    baseUrl?: string;
+    /** Embedding model to use */
+    model?: string;
+}
+
+/**
+ * Memory Retrieval Tool
+ *
+ * Provides a tool for LLMs to search through past conversation messages
+ * using semantic similarity.
+ */
+
+/**
+ * Creates a memory retrieval tool for use with chat completions.
+ *
+ * The tool allows the LLM to search through past conversation messages
+ * using semantic similarity. Messages must have embeddings stored to be searchable.
+ *
+ * @param storageCtx - Storage operations context for database access
+ * @param embeddingOptions - Options for embedding generation
+ * @param searchOptions - Default search options (can be overridden per-call)
+ * @returns A ToolConfig that can be passed to chat completion tools
+ *
+ * @example
+ * ```ts
+ * const tool = createMemoryRetrievalTool(
+ *   storageCtx,
+ *   { getToken: () => getIdentityToken() },
+ *   { limit: 5, minSimilarity: 0.4 }
+ * );
+ *
+ * // Use with chat completion
+ * const result = await sendMessage({
+ *   messages: [...],
+ *   tools: [tool],
+ * });
+ * ```
+ */
+declare function createMemoryRetrievalTool(storageCtx: StorageOperationsContext, embeddingOptions: EmbeddingOptions, searchOptions?: Partial<MemoryRetrievalSearchOptions>): ToolConfig;
+
+/**
+ * Memory Retrieval Embeddings
+ *
+ * Functions for generating and storing embeddings for conversation messages.
+ */
+
+/**
+ * Generate an embedding for text using the API
+ *
+ * Supports two auth methods:
+ * - `apiKey`: Uses X-API-Key header (for server-side/CLI usage)
+ * - `getToken`: Uses Authorization: Bearer header (for Privy identity tokens)
+ */
+declare function generateEmbedding(text: string, options: EmbeddingOptions): Promise<number[]>;
+/**
+ * Generate embeddings for multiple texts in a single API call
+ *
+ * More efficient than calling generateEmbedding multiple times.
+ * Supports the same auth methods as generateEmbedding.
+ *
+ * @param texts - Array of texts to embed
+ * @param options - Embedding options
+ * @returns Array of embeddings in the same order as input texts
+ */
+declare function generateEmbeddings(texts: string[], options: EmbeddingOptions): Promise<number[][]>;
+/**
+ * Embed a single message and store the embedding in the database
+ *
+ * @param ctx - Storage operations context
+ * @param messageId - Unique ID of the message to embed
+ * @param options - Embedding options
+ * @returns The updated message with embedding, or null if message not found
+ */
+declare function embedMessage(ctx: StorageOperationsContext, messageId: string, options: EmbeddingOptions): Promise<StoredMessage | null>;
+/**
+ * Embed all messages without embeddings in the database
+ *
+ * @param ctx - Storage operations context
+ * @param options - Embedding options
+ * @param filter - Optional filter for which messages to embed
+ * @returns Number of messages embedded
+ */
+declare function embedAllMessages(ctx: StorageOperationsContext, options: EmbeddingOptions, filter?: {
+    /** Only embed messages from this conversation */
+    conversationId?: string;
+    /** Only embed messages with these roles */
+    roles?: ("user" | "assistant")[];
+    /** Minimum content length to embed (default: 30). Shorter messages are skipped. */
+    minContentLength?: number;
+}): Promise<number>;
+
+/**
+ * Queue Types
+ *
+ * Types for the in-memory write queue that holds operations
+ * when encryption keys aren't yet available.
+ */
+
+/**
+ * Types of database operations that can be queued.
+ */
+type QueuedOperationType = "createConversation" | "updateConversationTitle" | "createMessage" | "updateMessage" | "createMedia" | "createMediaBatch" | "updateMediaMessageId";
+/**
+ * A single queued database operation.
+ */
+interface QueuedOperation {
+    /** Unique ID for this operation */
+    id: string;
+    /** Type of operation */
+    type: QueuedOperationType;
+    /** Wallet address this operation belongs to */
+    walletAddress: string;
+    /** When the operation was queued */
+    timestamp: number;
+    /** Priority for ordering (lower = higher priority). Conversations=0, Messages=1, Media=2 */
+    priority: number;
+    /** IDs of operations that must complete before this one */
+    dependencies: string[];
+    /** Operation-specific payload */
+    payload: Record<string, any>;
+    /** Number of times this operation has been retried */
+    retryCount: number;
+    /** Maximum number of retries allowed */
+    maxRetries: number;
+}
+/**
+ * Status of a wallet's queue.
+ */
+interface QueueStatus {
+    /** Number of pending operations */
+    pending: number;
+    /** Number of operations that failed all retries */
+    failed: number;
+    /** Whether the queue is currently being flushed */
+    isFlushing: boolean;
+    /** Whether the queue is paused (e.g., wallet disconnected) */
+    isPaused: boolean;
+}
+/**
+ * Result of a flush operation.
+ */
+interface FlushResult {
+    /** IDs of operations that succeeded */
+    succeeded: string[];
+    /** Operations that failed with their errors */
+    failed: Array<{
+        id: string;
+        error: string;
+    }>;
+    /** Total number of operations attempted */
+    total: number;
+}
+/**
+ * Encryption context needed to execute queued operations.
+ */
+interface QueueEncryptionContext {
+    walletAddress: string;
+    signMessage: SignMessageFn;
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+}
+/**
+ * Executor function that runs a single queued operation.
+ * Provided by the consumer (e.g., useChatStorage) during flush.
+ */
+type OperationExecutor = (operation: QueuedOperation, encryptionContext: QueueEncryptionContext) => Promise<void>;
+
+/**
+ * Queue Manager
+ *
+ * In-memory queue for database operations when encryption keys aren't yet available.
+ * Operations are held in memory and flushed to the database once the key becomes available.
+ *
+ * Key design decisions:
+ * - In-memory only: queue is lost on page refresh (acceptable since user must re-auth anyway)
+ * - Per-wallet isolation: each wallet has its own queue
+ * - Dependency tracking: operations are flushed in correct order (conversation before messages)
+ * - Max 1000 operations per wallet to prevent memory leaks
+ */
+
+declare class QueueManager {
+    /** Per-wallet operation queues: wallet address -> operation id -> operation */
+    private queues;
+    /** Per-wallet flushing state */
+    private flushing;
+    /** Per-wallet paused state */
+    private paused;
+    /** Per-wallet failed operations (exceeded max retries) */
+    private failedOps;
+    /** Change listeners: wallet address -> callbacks */
+    private listeners;
+    /**
+     * Queue a new operation for a wallet.
+     * @returns The operation ID, or null if queue is full.
+     */
+    queueOperation(walletAddress: string, type: QueuedOperationType, payload: Record<string, any>, dependencies?: string[], maxRetries?: number): string | null;
+    /**
+     * Get all pending operations for a wallet, sorted by dependency order.
+     */
+    getOperations(walletAddress: string): QueuedOperation[];
+    /**
+     * Remove a specific operation from the queue.
+     */
+    removeOperation(walletAddress: string, operationId: string): void;
+    /**
+     * Get the status of a wallet's queue.
+     */
+    getStatus(walletAddress: string): QueueStatus;
+    /**
+     * Flush all queued operations for a wallet by executing them with encryption.
+     *
+     * @param encryptionContext - Wallet address and signing functions for encryption
+     * @param executor - Function that executes each operation against the database
+     * @returns Result with succeeded/failed operation IDs
+     */
+    flush(encryptionContext: QueueEncryptionContext, executor: OperationExecutor): Promise<FlushResult>;
+    /**
+     * Clear all queued operations for a wallet.
+     */
+    clear(walletAddress: string): void;
+    /**
+     * Pause the queue for a wallet (stops flush mid-way).
+     */
+    pause(walletAddress: string): void;
+    /**
+     * Resume the queue for a wallet.
+     */
+    resume(walletAddress: string): void;
+    /**
+     * Register a listener for queue changes on a wallet.
+     * @returns Unsubscribe function
+     */
+    onQueueChange(walletAddress: string, callback: () => void): () => void;
+    /**
+     * Check if a wallet has any pending operations.
+     */
+    hasPending(walletAddress: string): boolean;
+    /** Move a failed operation to the failed set. */
+    private moveToFailed;
+    /** Notify all listeners for a wallet. */
+    private notifyListeners;
+}
+/** Singleton queue manager instance */
+declare const queueManager: QueueManager;
+
+/**
+ * Wallet Poller
+ *
+ * Polls for embedded wallet availability during Privy initialization.
+ * When a wallet becomes available, triggers a callback so the queue can flush.
+ */
+declare class WalletPoller {
+    private timerId;
+    private attempts;
+    /**
+     * Start polling for wallet availability.
+     *
+     * @param checkWallet - Returns wallet address when ready, null if not yet available
+     * @param onWalletReady - Called with the wallet address when it becomes available
+     * @param intervalMs - Polling interval in milliseconds (default: 1000ms)
+     * @param maxAttempts - Maximum polling attempts before giving up (default: 60)
+     * @returns Stop function to cancel polling
+     */
+    startPolling(checkWallet: () => Promise<string | null>, onWalletReady: (address: string) => void, intervalMs?: number, maxAttempts?: number): () => void;
+    /**
+     * Stop polling.
+     */
+    stop(): void;
+}
+
+/**
+ * Options for useChatStorage hook (Expo version)
+ *
+ * Uses the base options without React-specific features (no local chat, no tools).
+ * @inline
+ */
+interface UseChatStorageOptions extends BaseUseChatStorageOptions {
+    /**
+     * Which API endpoint to use. Default: "responses"
+     * - "responses": OpenAI Responses API (supports thinking, reasoning, conversations)
+     * - "completions": OpenAI Chat Completions API (wider model compatibility)
+     */
+    apiType?: ApiType;
+    /**
+     * Wallet address for field-level encryption.
+     * When provided with signMessage, all sensitive content is encrypted at rest.
+     */
+    walletAddress?: string;
+    /**
+     * Function to sign a message for encryption key derivation.
+     */
+    signMessage?: SignMessageFn;
+    /**
+     * Function for silent signing with Privy embedded wallets.
+     */
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+    /**
+     * Async function to poll for wallet address during Privy initialization.
+     */
+    getWalletAddress?: () => Promise<string | null>;
+    /**
+     * Enable the in-memory write queue. @default true
+     */
+    enableQueue?: boolean;
+    /**
+     * Auto-flush queued operations when key becomes available. @default true
+     */
+    autoFlushOnKeyAvailable?: boolean;
+}
+/**
+ * Arguments for sendMessage with storage (Expo version)
+ *
+ * Uses the base arguments without React-specific features (no runTools, no headers).
+
+ */
+type SendMessageWithStorageArgs = BaseSendMessageWithStorageArgs & {
+    /**
+     * Override the API type for this request only.
+     * Useful when different models need different APIs.
+     * @default Uses the hook-level apiType or "responses"
+     */
+    apiType?: ApiType;
+};
+/**
+ * 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>;
+    /**
+     * Create a memory retrieval tool for LLM to search past conversations.
+     * The tool is pre-configured with the hook's storage context and auth.
+     *
+     * @param searchOptions - Optional search configuration (limit, minSimilarity, etc.)
+     * @returns A ToolConfig that can be passed to sendMessage's clientTools
+     *
+     * @example
+     * ```ts
+     * const memoryTool = createMemoryRetrievalTool({ limit: 5 });
+     * await sendMessage({
+     *   messages: [...],
+     *   clientTools: [memoryTool],
+     * });
+     * ```
+     */
+    createMemoryRetrievalTool: (searchOptions?: Partial<MemoryRetrievalSearchOptions>) => ToolConfig;
+    /** Manually flush all queued operations for the current wallet. */
+    flushQueue: () => Promise<FlushResult>;
+    /** Clear all queued operations without writing them. */
+    clearQueue: () => void;
+    /** Current status of the write queue. */
+    queueStatus: QueueStatus;
+}
+/**
+ * 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 '@anuma/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;
+
+/**
+ * @inline
+ */
+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;
+
+/**
+ * @inline
+ */
+type UseCreditsOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Whether to fetch credit balance automatically on mount (default: true)
+     */
+    autoFetch?: boolean;
+    /**
+     * Optional callback for error handling
+     */
+    onError?: (error: Error) => void;
+};
+type UseCreditsResult = {
+    /**
+     * Current credit balance and related info
+     */
+    balance: HandlersCreditBalanceResponse | null;
+    /**
+     * Available credit packs for purchase
+     */
+    packs: HandlersCreditPack[];
+    /**
+     * Whether any operation is in progress
+     */
+    isLoading: boolean;
+    /**
+     * Error from the last operation
+     */
+    error: Error | null;
+    /**
+     * Refetch the credit balance
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Fetch available credit packs
+     */
+    fetchPacks: () => Promise<void>;
+    /**
+     * Claim free daily credits (once per 24 hours)
+     * @returns The claim response or null on error
+     */
+    claimDailyCredits: () => Promise<HandlersClaimDailyCreditsResponse | null>;
+    /**
+     * Create a Stripe checkout session for purchasing a credit pack
+     * @param credits - Number of credits to purchase
+     * @returns The checkout URL or null on error
+     */
+    purchaseCredits: (credits: number, options?: {
+        successUrl?: string;
+        cancelUrl?: string;
+    }) => Promise<string | null>;
+};
+/**
+ * React hook for managing credits: checking balance, claiming daily credits,
+ * browsing packs, and purchasing credits.
+ * @category Hooks
+ */
+declare function useCredits(options?: UseCreditsOptions): UseCreditsResult;
+
+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.
+ * @inline
+ */
+interface UseMemoryStorageOptions extends 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 '@anuma/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;
+
+/**
+ * Current combined schema version for all SDK storage modules.
+ *
+ * Version history:
+ * - v2: Baseline (chat + memory tables) - minimum supported version for migrations
+ * - v3: Added was_stopped column to history table
+ * - v4: Added modelPreferences table for settings storage
+ * - v5: Added error column to history table for error persistence
+ * - v6: Added thought_process column to history table for activity tracking
+ * - v7: Added userPreferences table for unified user settings storage
+ * - v8: BREAKING - Clear all data (switching embedding model from OpenAI to Fireworks)
+ * - v9: Added thinking column to history table for reasoning/thinking content
+ * - v10: Added projects table and project_id column to conversations table
+ * - v11: Added media table for library feature, added file_ids column to history table
+ * - v12: Added chunks column to history table for sub-message semantic search
+ */
+declare const SDK_SCHEMA_VERSION = 12;
+/**
+ * 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 (deprecated, use userPreferences)
+ * - `userPreferences`: Unified user preferences (profile, personality, models)
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@nozbe/watermelondb';
+ * import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs';
+ * import { sdkSchema, sdkMigrations, sdkModelClasses } from '@anuma/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
+ * - v6 → v7: Added `userPreferences` table for unified user settings storage
+ * - v7 → v8: BREAKING - Clear all data (embedding model change)
+ * - v8 → v9: Added `thinking` column to history table for reasoning/thinking content
+ * - v9 → v10: Added `projects` table and `project_id` column to conversations
+ * - v10 → v11: Added `media` table for library feature, added `file_ids` column to history
+ * - v11 → v12: Added `chunks` column to history table for sub-message semantic search
+ */
+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 '@anuma/sdk/react';
+ *
+ * const database = new Database({
+ *   adapter,
+ *   modelClasses: sdkModelClasses,
+ * });
+ * ```
+ */
+declare const sdkModelClasses: Class<Model$1>[];
+
+/**
+ * Platform abstraction for persistent and session storage.
+ *
+ * Web implementations use localStorage/sessionStorage/indexedDB.
+ * Mobile implementations can use AsyncStorage/in-memory maps/SQLite cleanup.
+ */
+interface PlatformStorage {
+    /** Read a value from persistent storage (e.g. localStorage) */
+    getItem(key: string): string | null;
+    /** Write a value to persistent storage */
+    setItem(key: string, value: string): void;
+    /** Remove a value from persistent storage */
+    removeItem(key: string): void;
+    /** Read a value from session-scoped storage (e.g. sessionStorage). Used to prevent reload loops. */
+    getSessionItem(key: string): string | null;
+    /** Write a value to session-scoped storage */
+    setSessionItem(key: string, value: string): void;
+    /** Delete an IndexedDB database by name */
+    deleteDatabase(name: string): Promise<void>;
+}
+/**
+ * Optional logger interface for DatabaseManager.
+ */
+interface DatabaseManagerLogger {
+    debug?: (msg: string, ctx?: Record<string, unknown>) => void;
+    warn?: (msg: string, ctx?: Record<string, unknown>) => void;
+    info?: (msg: string, ctx?: Record<string, unknown>) => void;
+}
+/**
+ * Configuration options for DatabaseManager.
+ */
+interface DatabaseManagerOptions {
+    /** Prefix for database names, e.g. "anuma-watermelon". Each wallet gets `{prefix}-{address}`. */
+    dbNamePrefix: string;
+    /**
+     * Factory that creates a WatermelonDB adapter for a given database name.
+     * The schema and migrations are provided for convenience.
+     *
+     * @example
+     * ```typescript
+     * createAdapter: (dbName, schema, migrations) => new LokiJSAdapter({
+     *   schema,
+     *   migrations,
+     *   dbName,
+     *   useWebWorker: false,
+     *   useIncrementalIndexedDB: true,
+     * })
+     * ```
+     */
+    createAdapter: (dbName: string, schema: typeof sdkSchema, migrations: typeof sdkMigrations) => DatabaseAdapter;
+    /** Platform storage implementation. Defaults to webPlatformStorage. */
+    storage?: PlatformStorage;
+    /**
+     * Called when a destructive migration is needed (schema too old).
+     * On web, this typically triggers `window.location.reload()`.
+     * If not provided, the manager will throw an error instead.
+     */
+    onDestructiveMigration?: () => void;
+    /** Optional logger for debug/warn/info messages */
+    logger?: DatabaseManagerLogger;
+}
+/**
+ * Manages per-wallet WatermelonDB database instances.
+ *
+ * Each wallet address gets its own isolated database. The manager handles:
+ * - Singleton caching per wallet
+ * - Automatic database switching when the wallet changes
+ * - Destructive schema migration detection and handling
+ * - Per-wallet storage key namespacing
+ *
+ * @example
+ * ```typescript
+ * import { DatabaseManager, webPlatformStorage, sdkSchema, sdkMigrations } from '@anuma/sdk/react';
+ * import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs';
+ *
+ * const dbManager = new DatabaseManager({
+ *   dbNamePrefix: 'my-app',
+ *   createAdapter: (dbName, schema, migrations) => new LokiJSAdapter({
+ *     schema,
+ *     migrations,
+ *     dbName,
+ *     useWebWorker: false,
+ *     useIncrementalIndexedDB: true,
+ *   }),
+ *   storage: webPlatformStorage,
+ *   onDestructiveMigration: () => window.location.reload(),
+ * });
+ *
+ * // Get the database for the current wallet
+ * const database = dbManager.getDatabase(walletAddress);
+ * ```
+ */
+declare class DatabaseManager {
+    private database;
+    private currentWalletAddress;
+    private migrationInProgress;
+    private readonly dbNamePrefix;
+    private readonly createAdapter;
+    private readonly storage;
+    private readonly onDestructiveMigration?;
+    private readonly logger;
+    constructor(options: DatabaseManagerOptions);
+    /**
+     * Get the database name for a given wallet address.
+     */
+    getDbName(walletAddress?: string): string;
+    /**
+     * Get or create a WatermelonDB Database instance for the given wallet.
+     *
+     * If the wallet address has changed since the last call, the previous
+     * database instance is discarded and a new one is created.
+     *
+     * @param walletAddress - The wallet address to scope the database to.
+     *   If undefined, uses a "guest" database.
+     * @returns The WatermelonDB Database instance
+     * @throws If a destructive migration is in progress
+     */
+    getDatabase(walletAddress?: string): Database;
+    /**
+     * Reset the current database (useful for logout or testing).
+     */
+    resetDatabase(): Promise<void>;
+    /**
+     * Check and handle schema migrations for a specific wallet.
+     * Returns true if a destructive migration is in progress.
+     */
+    private handleSchemaMigration;
+}
+
+export { type CachedServerTools, Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, DEFAULT_CACHE_EXPIRATION_MS, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type EmbeddedWalletSignerFn, type FileMetadata, type FlushResult, type MemoryItem, type EmbeddingOptions as MemoryRetrievalEmbeddingOptions, type MemoryRetrievalResult, type MemoryRetrievalSearchOptions, type MemoryType, type PlatformStorage, QueueManager, type QueueStatus, SDK_SCHEMA_VERSION, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type ServerToolsOptions, type ServerToolsResponse, type SignMessageFn, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredMemory, Memory as StoredMemoryModel, type StoredMemoryWithSimilarity, type StoredMessage, type StoredMessageWithSimilarity, type UpdateMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseMemoryStorageOptions, type UseMemoryStorageResult, type UseModelsOptions, type UseModelsResult, WalletPoller, chatStorageMigrations, chatStorageSchema, clearAllEncryptionKeys, clearEncryptionKey, clearServerToolsCache, createMemoryRetrievalTool, embedAllMessages, embedMessage, generateCompositeKey, generateConversationId, generateEmbedding, generateEmbeddings, generateUniqueKey, getCachedServerTools, getServerTools, hasEncryptionKey, memoryStorageSchema, onKeyAvailable, queueManager, requestEncryptionKey, sdkMigrations, sdkModelClasses, sdkSchema, useChat, useChatStorage, useCredits, useEncryption, useMemoryStorage, useModels };