@voltagent/libsql 0.1.0 → 1.0.0-next.1

package/dist/index.d.mts

@@ -1,117 +1,201 @@
-import { WorkflowHistoryEntry, WorkflowStepHistoryEntry, WorkflowTimelineEvent, WorkflowStats, MemoryOptions, Memory, MessageFilterOptions, MemoryMessage, NewTimelineEvent, CreateConversationInput, Conversation, ConversationQueryOptions } from '@voltagent/core';
+import { StorageAdapter, GetMessagesOptions, CreateConversationInput, Conversation, ConversationQueryOptions, WorkingMemoryScope, WorkflowStateEntry, ObservabilityStorageAdapter, ObservabilitySpan, ObservabilityLogRecord, LogFilter, VectorAdapter, VectorItem, VectorSearchOptions, SearchResult } from '@voltagent/core';
 import { Logger } from '@voltagent/logger';
-import { Client } from '@libsql/client';
+import { UIMessage } from 'ai';
 
 /**
- * LibSQL extension for workflow memory operations
- * This class provides workflow-specific storage operations for LibSQL
+ * LibSQL Storage Adapter for Memory
+ * Stores conversations and messages in SQLite/Turso database
+ * Compatible with existing LibSQL storage structure
  */
-declare class LibSQLWorkflowExtension {
+
+/**
+ * LibSQL configuration options for Memory
+ */
+interface LibSQLMemoryOptions {
+    /**
+     * Database URL (e.g., 'file:./conversations.db' or 'libsql://...')
+     * @default "file:./.voltagent/memory.db"
+     */
+    url?: string;
+    /**
+     * Auth token for remote connections (optional)
+     */
+    authToken?: string;
+    /**
+     * Maximum number of messages to store per conversation
+     * @default 100
+     */
+    storageLimit?: number;
+    /**
+     * Prefix for table names
+     * @default "voltagent_memory"
+     */
+    tablePrefix?: string;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Logger instance
+     */
+    logger?: Logger;
+    /**
+     * Maximum number of retries for database operations
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Initial retry delay in milliseconds
+     * @default 100
+     */
+    retryDelayMs?: number;
+}
+/**
+ * LibSQL Storage Adapter for Memory
+ * Production-ready storage for conversations and messages
+ * Compatible with existing LibSQL storage structure
+ */
+declare class LibSQLMemoryAdapter implements StorageAdapter {
     private client;
-    private _tablePrefix;
+    private storageLimit;
+    private tablePrefix;
+    private initialized;
     private logger;
-    constructor(client: Client, _tablePrefix?: string, logger?: Logger);
+    private maxRetries;
+    private retryDelayMs;
+    private url;
+    constructor(options?: LibSQLMemoryOptions);
+    /**
+     * Execute a database operation with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Initialize database schema
+     */
+    private initialize;
     /**
-     * Store a workflow history entry
+     * Add new columns to messages table for V2 format if they don't exist
+     * This allows existing tables to support both old and new message formats
      */
-    storeWorkflowHistory(entry: WorkflowHistoryEntry): Promise<void>;
+    private addV2ColumnsToMessagesTable;
     /**
-     * Get a workflow history entry by ID
+     * Migrate default user_id values in messages table
+     * Updates messages with user_id='default' to use the actual user_id from their conversation
      */
-    getWorkflowHistory(id: string): Promise<WorkflowHistoryEntry | null>;
+    private migrateDefaultUserIds;
     /**
-     * Get all workflow history entries for a specific workflow
+     * Add a single message
      */
-    getWorkflowHistoryByWorkflowId(workflowId: string): Promise<WorkflowHistoryEntry[]>;
+    addMessage(message: UIMessage, userId: string, conversationId: string): Promise<void>;
     /**
-     * Update a workflow history entry
+     * Add multiple messages
      */
-    updateWorkflowHistory(id: string, updates: Partial<WorkflowHistoryEntry>): Promise<void>;
+    addMessages(messages: UIMessage[], userId: string, conversationId: string): Promise<void>;
     /**
-     * Delete a workflow history entry
+     * Apply storage limit to a conversation
      */
-    deleteWorkflowHistory(id: string): Promise<void>;
+    private applyStorageLimit;
     /**
-     * Store a workflow step entry
+     * Get messages with optional filtering
      */
-    storeWorkflowStep(step: WorkflowStepHistoryEntry): Promise<void>;
+    getMessages(userId: string, conversationId: string, options?: GetMessagesOptions): Promise<UIMessage[]>;
     /**
-     * Get a workflow step by ID
+     * Clear messages for a user
      */
-    getWorkflowStep(id: string): Promise<WorkflowStepHistoryEntry | null>;
+    clearMessages(userId: string, conversationId?: string): Promise<void>;
     /**
-     * Get all workflow steps for a specific workflow history
+     * Create a new conversation
      */
-    getWorkflowSteps(workflowHistoryId: string): Promise<WorkflowStepHistoryEntry[]>;
+    createConversation(input: CreateConversationInput): Promise<Conversation>;
     /**
-     * Update a workflow step
+     * Get a conversation by ID
      */
-    updateWorkflowStep(id: string, updates: Partial<WorkflowStepHistoryEntry>): Promise<void>;
+    getConversation(id: string): Promise<Conversation | null>;
     /**
-     * Delete a workflow step
+     * Get conversations by resource ID
      */
-    deleteWorkflowStep(id: string): Promise<void>;
+    getConversations(resourceId: string): Promise<Conversation[]>;
     /**
-     * Store a workflow timeline event
+     * Get conversations by user ID
      */
-    storeWorkflowTimelineEvent(event: WorkflowTimelineEvent): Promise<void>;
+    getConversationsByUserId(userId: string, options?: Omit<ConversationQueryOptions, "userId">): Promise<Conversation[]>;
     /**
-     * Get a workflow timeline event by ID
+     * Query conversations with filters
      */
-    getWorkflowTimelineEvent(id: string): Promise<WorkflowTimelineEvent | null>;
+    queryConversations(options: ConversationQueryOptions): Promise<Conversation[]>;
     /**
-     * Get all workflow timeline events for a specific workflow history
+     * Update a conversation
      */
-    getWorkflowTimelineEvents(workflowHistoryId: string): Promise<WorkflowTimelineEvent[]>;
+    updateConversation(id: string, updates: Partial<Omit<Conversation, "id" | "createdAt" | "updatedAt">>): Promise<Conversation>;
     /**
-     * Delete a workflow timeline event
+     * Delete a conversation
      */
-    deleteWorkflowTimelineEvent(id: string): Promise<void>;
+    deleteConversation(id: string): Promise<void>;
     /**
-     * Get all workflow IDs
+     * Get working memory
      */
-    getAllWorkflowIds(): Promise<string[]>;
+    getWorkingMemory(params: {
+        conversationId?: string;
+        userId?: string;
+        scope: WorkingMemoryScope;
+    }): Promise<string | null>;
     /**
-     * Get workflow statistics
+     * Set working memory
      */
-    getWorkflowStats(workflowId: string): Promise<WorkflowStats>;
+    setWorkingMemory(params: {
+        conversationId?: string;
+        userId?: string;
+        content: string;
+        scope: WorkingMemoryScope;
+    }): Promise<void>;
     /**
-     * Get workflow history with all related data (steps and events)
+     * Delete working memory
      */
-    getWorkflowHistoryWithStepsAndEvents(id: string): Promise<WorkflowHistoryEntry | null>;
+    deleteWorkingMemory(params: {
+        conversationId?: string;
+        userId?: string;
+        scope: WorkingMemoryScope;
+    }): Promise<void>;
     /**
-     * Delete workflow history and all related data
+     * Get workflow state by execution ID
      */
-    deleteWorkflowHistoryWithRelated(id: string): Promise<void>;
+    getWorkflowState(executionId: string): Promise<WorkflowStateEntry | null>;
     /**
-     * Clean up old workflow histories
+     * Set workflow state
      */
-    cleanupOldWorkflowHistories(workflowId: string, maxEntries: number): Promise<number>;
+    setWorkflowState(executionId: string, state: WorkflowStateEntry): Promise<void>;
     /**
-     * Parse workflow history row from database
+     * Update workflow state
      */
-    private parseWorkflowHistoryRow;
+    updateWorkflowState(executionId: string, updates: Partial<WorkflowStateEntry>): Promise<void>;
     /**
-     * Parse workflow step row from database
+     * Get suspended workflow states for a workflow
      */
-    private parseWorkflowStepRow;
+    getSuspendedWorkflowStates(workflowId: string): Promise<WorkflowStateEntry[]>;
     /**
-     * Parse workflow timeline event row from database
+     * Close database connection
      */
-    private parseWorkflowTimelineEventRow;
+    close(): Promise<void>;
 }
 
 /**
- * Options for configuring the LibSQLStorage
+ * LibSQL Observability Adapter
+ * Provides persistent storage for OpenTelemetry spans using LibSQL/Turso database
+ * Part of the OpenTelemetry observability migration (Phase 3)
+ */
+
+/**
+ * Options for configuring the LibSQLObservabilityAdapter
  */
-interface LibSQLStorageOptions extends MemoryOptions {
+interface LibSQLObservabilityOptions {
     /**
      * LibSQL connection URL
      * Can be either a remote Turso URL or a local file path
-     * @default "file:./.voltagent/memory.db"
+     * @default "file:./.voltagent/observability.db"
      * @example "libsql://your-database.turso.io" for remote Turso
-     * @example "file:memory.db" for local SQLite in current directory
-     * @example "file:.voltagent/memory.db" for local SQLite in .voltagent folder
+     * @example "file:observability.db" for local SQLite in current directory
+     * @example "file:.voltagent/observability.db" for local SQLite in .voltagent folder
      */
     url?: string;
     /**
@@ -121,7 +205,7 @@ interface LibSQLStorageOptions extends MemoryOptions {
     authToken?: string;
     /**
      * Prefix for table names
-     * @default "voltagent_memory"
+     * @default "observability"
      */
     tablePrefix?: string;
     /**
@@ -130,390 +214,257 @@ interface LibSQLStorageOptions extends MemoryOptions {
      */
     debug?: boolean;
     /**
-     * Storage limit for the LibSQLStorage
-     * @default 100
+     * Optional logger instance
      */
-    storageLimit?: number;
+    logger?: Logger;
     /**
-     * Number of retry attempts for database operations when encountering busy/locked errors
-     * @default 3
+     * Maximum number of spans to return in a single query
+     * @default 1000
      */
-    retryAttempts?: number;
+    maxSpansPerQuery?: number;
+}
+/**
+ * LibSQL Observability Adapter
+ * Provides observability storage using LibSQL/Turso database
+ * Implements the ObservabilityStorageAdapter interface for OpenTelemetry spans
+ */
+declare class LibSQLObservabilityAdapter implements ObservabilityStorageAdapter {
+    private client;
+    private tablePrefix;
+    private debug;
+    private logger;
+    private initialized;
+    private maxSpansPerQuery;
+    constructor(options?: LibSQLObservabilityOptions);
     /**
-     * Base delay in milliseconds before retrying a failed operation
-     * Uses a jittered exponential backoff strategy for better load distribution
-     * @default 50
+     * Log a debug message if debug is enabled
      */
-    baseDelayMs?: number;
+    private debugLog;
     /**
-     * Optional logger instance
+     * Initialize database tables for observability
      */
-    logger?: Logger;
-}
-declare class LibSQLStorage implements Memory {
-    private client;
-    private options;
-    private initialized;
-    private workflowExtension;
-    private logger;
-    private retryAttempts;
-    private baseDelayMs;
+    private initializeDatabase;
     /**
-     * Create a new LibSQL storage
-     * @param options Configuration options
+     * Ensure database is initialized before operations
      */
-    constructor(options: LibSQLStorageOptions);
+    private ensureInitialized;
     /**
-     * Log a debug message if debug is enabled
-     * @param message Message to log
-     * @param data Additional data to log
+     * Add a span to the database
      */
-    private debug;
+    addSpan(span: ObservabilitySpan): Promise<void>;
     /**
-     * Calculate delay with jitter for better load distribution
-     * @param attempt Current retry attempt number
-     * @returns Delay in milliseconds
+     * Update an existing span
      */
-    private calculateRetryDelay;
+    updateSpan(spanId: string, updates: Partial<ObservabilitySpan>): Promise<void>;
     /**
-     * Execute a database operation with retry strategy
-     * Implements jittered exponential backoff
-     * @param operationFn The operation function to execute
-     * @param operationName Operation name for logging
-     * @returns The result of the operation
+     * Get a span by ID
      */
-    private executeWithRetryStrategy;
+    getSpan(spanId: string): Promise<ObservabilitySpan | null>;
     /**
-     * Initialize workflow tables
+     * Get all spans in a trace
      */
-    private initializeWorkflowTables;
+    getTrace(traceId: string): Promise<ObservabilitySpan[]>;
     /**
-     * Initialize the database tables
-     * @returns Promise that resolves when initialization is complete
+     * List all traces with optional entity filter
      */
-    private initializeDatabase;
+    listTraces(limit?: number, offset?: number, filter?: {
+        entityId?: string;
+        entityType?: "agent" | "workflow";
+    }): Promise<string[]>;
     /**
-     * Generate a unique ID for a message
-     * @returns Unique ID
+     * Delete old spans
      */
-    private generateId;
+    deleteOldSpans(beforeTimestamp: number): Promise<number>;
     /**
-     * Get messages with filtering options
-     * @param options Filtering options
-     * @returns Filtered messages
+     * Clear all spans, traces, and logs
      */
-    getMessages(options?: MessageFilterOptions): Promise<MemoryMessage[]>;
+    clear(): Promise<void>;
     /**
-     * Add a message to the conversation history
-     * @param message Message to add
-     * @param userId User identifier (optional, defaults to "default")
-     * @param conversationId Conversation identifier (optional, defaults to "default")
+     * Convert a database row to an ObservabilitySpan
      */
-    addMessage(message: MemoryMessage, conversationId?: string): Promise<void>;
+    private rowToSpan;
     /**
-     * Prune old messages to respect storage limit
-     * @param conversationId Conversation ID to prune messages for
+     * Get statistics about stored spans
      */
-    private pruneOldMessages;
+    getStats(): Promise<{
+        spanCount: number;
+        traceCount: number;
+        oldestSpan?: Date;
+        newestSpan?: Date;
+    }>;
     /**
-     * Clear messages from memory
+     * Save a log record to the database
      */
-    clearMessages(options: {
-        userId: string;
-        conversationId?: string;
-    }): Promise<void>;
+    saveLogRecord(logRecord: any): Promise<void>;
+    /**
+     * Get logs by trace ID
+     */
+    getLogsByTraceId(traceId: string): Promise<ObservabilityLogRecord[]>;
+    /**
+     * Get logs by span ID
+     */
+    getLogsBySpanId(spanId: string): Promise<ObservabilityLogRecord[]>;
+    /**
+     * Query logs with flexible filtering
+     */
+    queryLogs(filter: LogFilter): Promise<ObservabilityLogRecord[]>;
+    /**
+     * Delete old logs
+     */
+    deleteOldLogs(beforeTimestamp: number): Promise<number>;
+    /**
+     * Convert a database row to an ObservabilityLogRecord
+     */
+    private rowToLogRecord;
     /**
      * Close the database connection
      */
     close(): Promise<void>;
+}
+
+/**
+ * LibSQL Vector Adapter
+ * Provides vector storage and similarity search using LibSQL/Turso database
+ * Stores vectors as binary BLOBs for efficiency
+ */
+
+/**
+ * LibSQL Vector Adapter configuration options
+ */
+interface LibSQLVectorOptions {
     /**
-     * Add or update a history entry
-     * @param key Entry ID
-     * @param value Entry data
-     * @param agentId Agent ID for filtering
+     * Database URL (e.g., 'file:./memory.db' or 'libsql://...')
+     * @default "file:./.voltagent/memory.db"
      */
-    addHistoryEntry(key: string, value: any, agentId: string): Promise<void>;
+    url?: string;
     /**
-     * Update an existing history entry
-     * @param key Entry ID
-     * @param value Updated entry data
-     * @param agentId Agent ID for filtering
+     * Auth token for remote connections (optional)
      */
-    updateHistoryEntry(key: string, value: any, agentId: string): Promise<void>;
+    authToken?: string;
     /**
-     * Add a history step
-     * @param key Step ID
-     * @param value Step data
-     * @param historyId Related history entry ID
-     * @param agentId Agent ID for filtering
+     * Prefix for table names
+     * @default "voltagent"
      */
-    addHistoryStep(key: string, value: any, historyId: string, agentId: string): Promise<void>;
+    tablePrefix?: string;
     /**
-     * Update a history step
-     * @param key Step ID
-     * @param value Updated step data
-     * @param historyId Related history entry ID
-     * @param agentId Agent ID for filtering
+     * Maximum vector dimensions allowed
+     * @default 1536
      */
-    updateHistoryStep(key: string, value: any, historyId: string, agentId: string): Promise<void>;
+    maxVectorDimensions?: number;
     /**
-     * Add a timeline event
-     * @param key Event ID (UUID)
-     * @param value Timeline event data
-     * @param historyId Related history entry ID
-     * @param agentId Agent ID for filtering
+     * Size of the LRU cache for frequently accessed vectors
+     * @default 100
      */
-    addTimelineEvent(key: string, value: NewTimelineEvent, historyId: string, agentId: string): Promise<void>;
+    cacheSize?: number;
     /**
-     * Get a history entry by ID
-     * @param key Entry ID
-     * @returns The history entry or undefined if not found
+     * Batch size for bulk operations
+     * @default 100
      */
-    getHistoryEntry(key: string): Promise<any | undefined>;
+    batchSize?: number;
     /**
-     * Get a history step by ID
-     * @param key Step ID
-     * @returns The history step or undefined if not found
+     * Enable debug logging
+     * @default false
      */
-    getHistoryStep(key: string): Promise<any | undefined>;
-    createConversation(conversation: CreateConversationInput): Promise<Conversation>;
-    getConversation(id: string): Promise<Conversation | null>;
-    getConversations(resourceId: string): Promise<Conversation[]>;
-    getConversationsByUserId(userId: string, options?: Omit<ConversationQueryOptions, "userId">): Promise<Conversation[]>;
+    debug?: boolean;
     /**
-     * Query conversations with filtering and pagination options
-     *
-     * @param options Query options for filtering and pagination
-     * @returns Promise that resolves to an array of conversations matching the criteria
-     * @see {@link https://voltagent.dev/docs/agents/memory/libsql#querying-conversations | Querying Conversations}
+     * Logger instance
      */
-    queryConversations(options: ConversationQueryOptions): Promise<Conversation[]>;
+    logger?: Logger;
     /**
-     * Get messages for a specific conversation with pagination support
-     *
-     * @param conversationId The unique identifier of the conversation to retrieve messages from
-     * @param options Optional pagination and filtering options
-     * @returns Promise that resolves to an array of messages in chronological order (oldest first)
-     * @see {@link https://voltagent.dev/docs/agents/memory/libsql#conversation-messages | Getting Conversation Messages}
-     */
-    getConversationMessages(conversationId: string, options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<MemoryMessage[]>;
-    updateConversation(id: string, updates: Partial<Omit<Conversation, "id" | "createdAt" | "updatedAt">>): Promise<Conversation>;
-    deleteConversation(id: string): Promise<void>;
+     * Maximum number of retries for database operations
+     * @default 3
+     */
+    maxRetries?: number;
     /**
-     * Get all history entries for an agent with pagination
-     * @param agentId Agent ID
-     * @param page Page number (0-based)
-     * @param limit Number of entries per page
-     * @returns Object with entries array and total count
+     * Initial retry delay in milliseconds
+     * @default 100
      */
-    getAllHistoryEntriesByAgent(agentId: string, page: number, limit: number): Promise<{
-        entries: any[];
-        total: number;
-    }>;
+    retryDelayMs?: number;
+}
+/**
+ * LibSQL Vector Adapter
+ * Production-ready vector storage with similarity search
+ */
+declare class LibSQLVectorAdapter implements VectorAdapter {
+    private client;
+    private tablePrefix;
+    private maxVectorDimensions;
+    private cacheSize;
+    private batchSize;
+    private debug;
+    private logger;
+    private maxRetries;
+    private retryDelayMs;
+    private url;
+    private initialized;
+    private vectorCache;
+    private dimensions;
+    constructor(options?: LibSQLVectorOptions);
     /**
-     * Migrates agent history data from old structure to new structure.
-     * If migration fails, it can be rolled back using the backup mechanism.
-     *
-     * Old database structure:
-     * CREATE TABLE voltagent_memory_agent_history (
-     *   key TEXT PRIMARY KEY,
-     *   value TEXT NOT NULL,
-     *   agent_id TEXT
-     * );
-     */
-    migrateAgentHistoryData(options?: {
-        createBackup?: boolean;
-        restoreFromBackup?: boolean;
-        deleteBackupAfterSuccess?: boolean;
-    }): Promise<{
-        success: boolean;
-        migratedCount?: number;
-        error?: Error;
-        backupCreated?: boolean;
-    }>;
+     * Initialize the database schema
+     */
+    private initialize;
     /**
-     * Migrate conversation schema to add user_id and update messages table
-     *
-     * ⚠️  **CRITICAL WARNING: DESTRUCTIVE OPERATION** ⚠️
-     *
-     * This method performs a DESTRUCTIVE schema migration that:
-     * - DROPS and recreates existing tables
-     * - Creates temporary tables during migration
-     * - Modifies the primary key structure of the messages table
-     * - Can cause DATA LOSS if interrupted or if errors occur
-     *
-     * **IMPORTANT SAFETY REQUIREMENTS:**
-     * - 🛑 STOP all application instances before running this migration
-     * - 🛑 Ensure NO concurrent database operations are running
-     * - 🛑 Take a full database backup before running (independent of built-in backup)
-     * - 🛑 Test the migration on a copy of production data first
-     * - 🛑 Plan for downtime during migration execution
-     *
-     * **What this migration does:**
-     * 1. Creates backup tables (if createBackup=true)
-     * 2. Creates temporary tables with new schema
-     * 3. Migrates data from old tables to new schema
-     * 4. DROPS original tables
-     * 5. Renames temporary tables to original names
-     * 6. All operations are wrapped in a transaction for atomicity
-     *
-     * @param options Migration configuration options
-     * @param options.createBackup Whether to create backup tables before migration (default: true, HIGHLY RECOMMENDED)
-     * @param options.restoreFromBackup Whether to restore from existing backup instead of migrating (default: false)
-     * @param options.deleteBackupAfterSuccess Whether to delete backup tables after successful migration (default: false)
-     *
-     * @returns Promise resolving to migration result with success status, migrated count, and backup info
-     *
-     * @example
-     * ```typescript
-     * // RECOMMENDED: Run with backup creation (default)
-     * const result = await storage.migrateConversationSchema({
-     *   createBackup: true,
-     *   deleteBackupAfterSuccess: false // Keep backup for safety
-     * });
-     *
-     * if (result.success) {
-     *   console.log(`Migrated ${result.migratedCount} conversations successfully`);
-     * } else {
-     *   console.error('Migration failed:', result.error);
-     *   // Consider restoring from backup
-     * }
-     *
-     * // If migration fails, restore from backup:
-     * const restoreResult = await storage.migrateConversationSchema({
-     *   restoreFromBackup: true
-     * });
-     * ```
-     *
-     * @throws {Error} If migration fails and transaction is rolled back
-     *
-     * @since This migration is typically only needed when upgrading from older schema versions
-     */
-    private migrateConversationSchema;
-    /**
-     * Get conversations for a user with a fluent query builder interface
-     * @param userId User ID to filter by
-     * @returns Query builder object
-     */
-    getUserConversations(userId: string): {
-        /**
-         * Limit the number of results
-         * @param count Number of conversations to return
-         * @returns Query builder
-         */
-        limit: (count: number) => {
-            /**
-             * Order results by a specific field
-             * @param field Field to order by
-             * @param direction Sort direction
-             * @returns Query builder
-             */
-            orderBy: (field?: "created_at" | "updated_at" | "title", direction?: "ASC" | "DESC") => {
-                /**
-                 * Execute the query and return results
-                 * @returns Promise of conversations
-                 */
-                execute: () => Promise<Conversation[]>;
-            };
-            /**
-             * Execute the query with default ordering
-             * @returns Promise of conversations
-             */
-            execute: () => Promise<Conversation[]>;
-        };
-        /**
-         * Order results by a specific field
-         * @param field Field to order by
-         * @param direction Sort direction
-         * @returns Query builder
-         */
-        orderBy: (field?: "created_at" | "updated_at" | "title", direction?: "ASC" | "DESC") => {
-            /**
-             * Limit the number of results
-             * @param count Number of conversations to return
-             * @returns Query builder
-             */
-            limit: (count: number) => {
-                /**
-                 * Execute the query and return results
-                 * @returns Promise of conversations
-                 */
-                execute: () => Promise<Conversation[]>;
-            };
-            /**
-             * Execute the query without limit
-             * @returns Promise of conversations
-             */
-            execute: () => Promise<Conversation[]>;
-        };
-        /**
-         * Execute the query with default options
-         * @returns Promise of conversations
-         */
-        execute: () => Promise<Conversation[]>;
-    };
-    /**
-     * Get conversation by ID and ensure it belongs to the specified user
-     * @param conversationId Conversation ID
-     * @param userId User ID to validate ownership
-     * @returns Conversation or null
-     */
-    getUserConversation(conversationId: string, userId: string): Promise<Conversation | null>;
-    /**
-     * Get paginated conversations for a user
-     * @param userId User ID
-     * @param page Page number (1-based)
-     * @param pageSize Number of items per page
-     * @returns Object with conversations and pagination info
-     */
-    getPaginatedUserConversations(userId: string, page?: number, pageSize?: number): Promise<{
-        conversations: Conversation[];
-        page: number;
-        pageSize: number;
-        hasMore: boolean;
-    }>;
+     * Serialize a vector to binary format
+     */
+    private serializeVector;
+    /**
+     * Deserialize a vector from binary format
+     */
+    private deserializeVector;
+    /**
+     * Execute a database operation with retries
+     */
+    private executeWithRetry;
     /**
-     * Check and create migration flag table, return if migration already completed
-     * @param migrationType Type of migration to check
-     * @returns Object with completion status and details
-     */
-    private checkMigrationFlag;
-    /**
-     * Set migration flag after successful completion
-     * @param migrationType Type of migration completed
-     * @param migratedCount Number of records migrated
-     */
-    private setMigrationFlag;
-    /**
-     * Migrate agent history schema to add userId and conversationId columns
-     */
-    private migrateAgentHistorySchema;
-    storeWorkflowHistory(entry: any): Promise<void>;
-    getWorkflowHistory(id: string): Promise<any>;
-    getWorkflowHistoryByWorkflowId(workflowId: string): Promise<any[]>;
-    updateWorkflowHistory(id: string, updates: any): Promise<void>;
-    deleteWorkflowHistory(id: string): Promise<void>;
-    storeWorkflowStep(step: any): Promise<void>;
-    getWorkflowStep(id: string): Promise<any>;
-    getWorkflowSteps(workflowHistoryId: string): Promise<any[]>;
-    updateWorkflowStep(id: string, updates: any): Promise<void>;
-    deleteWorkflowStep(id: string): Promise<void>;
-    storeWorkflowTimelineEvent(event: any): Promise<void>;
-    getWorkflowTimelineEvent(id: string): Promise<any>;
-    getWorkflowTimelineEvents(workflowHistoryId: string): Promise<any[]>;
-    deleteWorkflowTimelineEvent(id: string): Promise<void>;
-    getAllWorkflowIds(): Promise<string[]>;
-    getWorkflowStats(workflowId: string): Promise<any>;
-    getWorkflowHistoryWithStepsAndEvents(id: string): Promise<any>;
-    deleteWorkflowHistoryWithRelated(id: string): Promise<void>;
-    cleanupOldWorkflowHistories(workflowId: string, maxEntries: number): Promise<number>;
-    /**
-     * Get the workflow extension for advanced workflow operations
-     */
-    getWorkflowExtension(): LibSQLWorkflowExtension;
+     * Store a vector with associated metadata
+     */
+    store(id: string, vector: number[], metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Store multiple vectors in batch
+     */
+    storeBatch(items: VectorItem[]): Promise<void>;
+    /**
+     * Search for similar vectors using cosine similarity
+     */
+    search(queryVector: number[], options?: VectorSearchOptions): Promise<SearchResult[]>;
+    /**
+     * Check if metadata matches the filter criteria
+     */
+    private matchesFilter;
+    /**
+     * Delete a vector by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Delete multiple vectors by IDs
+     */
+    deleteBatch(ids: string[]): Promise<void>;
+    /**
+     * Clear all vectors
+     */
+    clear(): Promise<void>;
+    /**
+     * Get total count of stored vectors
+     */
+    count(): Promise<number>;
+    /**
+     * Get a specific vector by ID
+     */
+    get(id: string): Promise<VectorItem | null>;
+    /**
+     * Close the database connection
+     */
+    close(): Promise<void>;
+    /**
+     * Get statistics about the vector table and cache
+     */
+    getStats(): Promise<{
+        count: number;
+        dimensions: number | null;
+        cacheSize: number;
+        tableSizeBytes: number;
+    }>;
 }
 
-export { LibSQLStorage, type LibSQLStorageOptions };
+export { LibSQLMemoryAdapter, type LibSQLMemoryOptions, LibSQLObservabilityAdapter, type LibSQLObservabilityOptions, LibSQLVectorAdapter, type LibSQLVectorOptions };