@voltagent/libsql 1.0.0-next.0 → 1.0.0-next.1

package/dist/index.mjs

@@ -1,2998 +1,2081 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/index.ts
-import { existsSync, mkdirSync } from "fs";
-import { dirname } from "path";
+// src/memory-v2-adapter.ts
+import fs from "fs";
+import path from "path";
 import { createClient } from "@libsql/client";
-import { safeJsonParse } from "@voltagent/core";
-import { safeStringify as safeStringify2 } from "@voltagent/internal/utils";
-import { createPinoLogger as createPinoLogger2 } from "@voltagent/logger";
-
-// src/migrations/add-suspended-status.ts
-async function addSuspendedStatusMigration(db, tablePrefix = "voltagent_memory") {
-  const migrationName = "add_suspended_status_to_workflow_history";
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS ${tablePrefix}_migrations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL UNIQUE,
-      applied_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `);
-  const result = await db.execute({
-    sql: `SELECT * FROM ${tablePrefix}_migrations WHERE name = ?`,
-    args: [migrationName]
-  });
-  if (result.rows.length > 0) {
-    return;
-  }
-  try {
-    const needsMigration = await checkIfSuspendedStatusNeeded(db, tablePrefix);
-    if (!needsMigration) {
-    } else {
-      await performSuspendedStatusMigration(db, tablePrefix);
+import {
+  AgentRegistry,
+  ConversationAlreadyExistsError,
+  ConversationNotFoundError
+} from "@voltagent/core";
+import { createPinoLogger } from "@voltagent/logger";
+var LibSQLMemoryAdapter = class {
+  static {
+    __name(this, "LibSQLMemoryAdapter");
+  }
+  client;
+  storageLimit;
+  tablePrefix;
+  initialized = false;
+  logger;
+  maxRetries;
+  retryDelayMs;
+  url;
+  constructor(options = {}) {
+    this.storageLimit = options.storageLimit ?? 100;
+    this.tablePrefix = options.tablePrefix ?? "voltagent_memory";
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 100;
+    this.logger = options.logger || AgentRegistry.getInstance().getGlobalLogger() || createPinoLogger({ name: "libsql-memory" });
+    this.url = options.url ?? "file:./.voltagent/memory.db";
+    if (this.url.startsWith("file:")) {
+      const dbPath = this.url.replace("file:", "");
+      const dbDir = path.dirname(dbPath);
+      if (dbDir && dbDir !== "." && !fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+        this.logger.debug(`Created database directory: ${dbDir}`);
+      }
     }
-    await db.execute({
-      sql: `INSERT INTO ${tablePrefix}_migrations (name) VALUES (?)`,
-      args: [migrationName]
-    });
-  } catch (error) {
-    console.error(`[Migration] Failed to apply '${migrationName}':`, error);
-    throw error;
-  }
-}
-__name(addSuspendedStatusMigration, "addSuspendedStatusMigration");
-async function checkIfSuspendedStatusNeeded(db, tablePrefix) {
-  try {
-    const testId = `test-suspended-check-${Date.now()}`;
-    await db.execute({
-      sql: `
-        INSERT INTO ${tablePrefix}_workflow_history 
-        (id, name, workflow_id, status, start_time) 
-        VALUES (?, 'test', 'test', 'suspended', datetime('now'))
-      `,
-      args: [testId]
-    });
-    await db.execute({
-      sql: `DELETE FROM ${tablePrefix}_workflow_history WHERE id = ?`,
-      args: [testId]
+    this.client = createClient({
+      url: this.url,
+      authToken: options.authToken
     });
-    return false;
-  } catch (error) {
-    if (error.message?.includes("CHECK constraint failed")) {
-      return true;
-    }
-    throw error;
-  }
-}
-__name(checkIfSuspendedStatusNeeded, "checkIfSuspendedStatusNeeded");
-async function performSuspendedStatusMigration(db, tablePrefix) {
-  await db.execute("BEGIN TRANSACTION");
-  try {
-    await db.execute(`
-      CREATE TABLE ${tablePrefix}_workflow_history_temp (
+    this.logger.debug("LibSQL Memory adapter initialized", { url: this.url });
+  }
+  /**
+   * Execute a database operation with retry logic
+   */
+  async executeWithRetry(operation, operationName) {
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (error?.code === "SQLITE_BUSY" || error?.message?.includes("SQLITE_BUSY") || error?.message?.includes("database is locked")) {
+          const delay = this.retryDelayMs * 2 ** attempt;
+          this.logger.debug(
+            `Database busy, retrying ${operationName} (attempt ${attempt + 1}/${this.maxRetries}) after ${delay}ms`
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          throw error;
+        }
+      }
+    }
+    this.logger.error(
+      `Failed to execute ${operationName} after ${this.maxRetries} attempts`,
+      lastError
+    );
+    throw lastError;
+  }
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const usersTable = `${this.tablePrefix}_users`;
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const isMemoryDb = this.url === ":memory:" || this.url.includes("mode=memory");
+    if (!isMemoryDb && (this.url.startsWith("file:") || this.url.startsWith("libsql:"))) {
+      try {
+        await this.client.execute("PRAGMA journal_mode=WAL");
+        this.logger.debug("Set PRAGMA journal_mode=WAL");
+      } catch (err) {
+        this.logger.debug("Failed to set PRAGMA journal_mode=WAL (non-critical)", { err });
+      }
+    }
+    try {
+      await this.client.execute("PRAGMA busy_timeout=5000");
+      this.logger.debug("Set PRAGMA busy_timeout=5000");
+    } catch (err) {
+      this.logger.debug("Failed to set PRAGMA busy_timeout (non-critical)", { err });
+    }
+    try {
+      await this.client.execute("PRAGMA foreign_keys=ON");
+      this.logger.debug("Set PRAGMA foreign_keys=ON");
+    } catch (err) {
+      this.logger.debug("Failed to set PRAGMA foreign_keys (non-critical)", { err });
+    }
+    this.logger.debug("Applied PRAGMA settings for better concurrency");
+    await this.executeWithRetry(async () => {
+      await this.client.batch([
+        // Create users table (for user-level working memory)
+        `CREATE TABLE IF NOT EXISTS ${usersTable} (
+        id TEXT PRIMARY KEY,
+        metadata TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      )`,
+        // Create conversations table (matching existing structure)
+        `CREATE TABLE IF NOT EXISTS ${conversationsTable} (
+        id TEXT PRIMARY KEY,
+        resource_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        metadata TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+        // Create messages table (matching existing structure)
+        `CREATE TABLE IF NOT EXISTS ${messagesTable} (
+        conversation_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        parts TEXT NOT NULL,
+        metadata TEXT,
+        format_version INTEGER DEFAULT 2,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, message_id)
+      )`,
+        // Create workflow states table
+        `CREATE TABLE IF NOT EXISTS ${workflowStatesTable} (
         id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
         workflow_id TEXT NOT NULL,
-        status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'error', 'cancelled', 'suspended')),
-        start_time TEXT NOT NULL,
-        end_time TEXT,
-        input TEXT,
-        output TEXT,
+        workflow_name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        suspension TEXT,
         user_id TEXT,
         conversation_id TEXT,
         metadata TEXT,
-        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await db.execute(`
-      INSERT INTO ${tablePrefix}_workflow_history_temp 
-      SELECT * FROM ${tablePrefix}_workflow_history
-    `);
-    await db.execute(`DROP TABLE ${tablePrefix}_workflow_history`);
-    await db.execute(`
-      ALTER TABLE ${tablePrefix}_workflow_history_temp 
-      RENAME TO ${tablePrefix}_workflow_history
-    `);
-    await db.execute(
-      `CREATE INDEX idx_${tablePrefix}_workflow_history_workflow_id ON ${tablePrefix}_workflow_history(workflow_id)`
-    );
-    await db.execute(
-      `CREATE INDEX idx_${tablePrefix}_workflow_history_status ON ${tablePrefix}_workflow_history(status)`
-    );
-    await db.execute(
-      `CREATE INDEX idx_${tablePrefix}_workflow_history_start_time ON ${tablePrefix}_workflow_history(start_time)`
-    );
-    await db.execute(
-      `CREATE INDEX idx_${tablePrefix}_workflow_history_user_id ON ${tablePrefix}_workflow_history(user_id)`
-    );
-    await db.execute(
-      `CREATE INDEX idx_${tablePrefix}_workflow_history_conversation_id ON ${tablePrefix}_workflow_history(conversation_id)`
-    );
-    await db.execute("COMMIT");
-  } catch (error) {
-    await db.execute("ROLLBACK");
-    throw error;
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+        // Create indexes for better performance
+        `CREATE INDEX IF NOT EXISTS idx_${conversationsTable}_user_id ON ${conversationsTable}(user_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${conversationsTable}_resource_id ON ${conversationsTable}(resource_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${messagesTable}_conversation_id ON ${messagesTable}(conversation_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${messagesTable}_created_at ON ${messagesTable}(created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_${workflowStatesTable}_workflow_id ON ${workflowStatesTable}(workflow_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${workflowStatesTable}_status ON ${workflowStatesTable}(status)`
+      ]);
+    }, "initialize database schema");
+    await this.addV2ColumnsToMessagesTable();
+    await this.migrateDefaultUserIds();
+    this.initialized = true;
+    this.logger.debug("Database schema initialized");
   }
-}
-__name(performSuspendedStatusMigration, "performSuspendedStatusMigration");
-
-// src/migrations/workflow-tables.ts
-async function createWorkflowTables(db, tablePrefix = "voltagent_memory") {
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS ${tablePrefix}_workflow_history (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      workflow_id TEXT NOT NULL,
-      status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'error', 'cancelled', 'suspended')),
-      start_time TEXT NOT NULL,
-      end_time TEXT,
-      input TEXT,
-      output TEXT,
-      user_id TEXT,
-      conversation_id TEXT,
-      metadata TEXT,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `);
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_history_workflow_id ON ${tablePrefix}_workflow_history(workflow_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_history_status ON ${tablePrefix}_workflow_history(status)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_history_start_time ON ${tablePrefix}_workflow_history(start_time)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_history_user_id ON ${tablePrefix}_workflow_history(user_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_history_conversation_id ON ${tablePrefix}_workflow_history(conversation_id)`
-  );
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS ${tablePrefix}_workflow_steps (
-      id TEXT PRIMARY KEY,
-      workflow_history_id TEXT NOT NULL,
-      step_index INTEGER NOT NULL,
-      step_type TEXT NOT NULL,
-      step_name TEXT NOT NULL,
-      step_id TEXT,
-      status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'error', 'skipped')),
-      start_time TEXT NOT NULL,
-      end_time TEXT,
-      input TEXT,
-      output TEXT,
-      error_message TEXT,
-      agent_execution_id TEXT,
-      parallel_index INTEGER,
-      parent_step_id TEXT,
-      metadata TEXT,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `);
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_steps_workflow_history ON ${tablePrefix}_workflow_steps(workflow_history_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_steps_agent_execution ON ${tablePrefix}_workflow_steps(agent_execution_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_steps_step_index ON ${tablePrefix}_workflow_steps(workflow_history_id, step_index)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_steps_parallel ON ${tablePrefix}_workflow_steps(parent_step_id, parallel_index)`
-  );
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS ${tablePrefix}_workflow_timeline_events (
-      id TEXT PRIMARY KEY,
-      workflow_history_id TEXT NOT NULL,
-      event_id TEXT NOT NULL,
-      name TEXT NOT NULL,
-      type TEXT NOT NULL CHECK (type IN ('workflow', 'workflow-step')),
-      start_time TEXT NOT NULL,
-      end_time TEXT,
-      status TEXT NOT NULL,
-      level TEXT DEFAULT 'INFO',
-      input TEXT,
-      output TEXT,
-      status_message TEXT,
-      metadata TEXT,
-      trace_id TEXT,
-      parent_event_id TEXT,
-      event_sequence INTEGER,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `);
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_timeline_events_workflow_history ON ${tablePrefix}_workflow_timeline_events(workflow_history_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_timeline_events_trace ON ${tablePrefix}_workflow_timeline_events(trace_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_timeline_events_parent ON ${tablePrefix}_workflow_timeline_events(parent_event_id)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_timeline_events_type ON ${tablePrefix}_workflow_timeline_events(type)`
-  );
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_workflow_timeline_events_sequence ON ${tablePrefix}_workflow_timeline_events(event_sequence)`
-  );
-  const checkWorkflowIdColumn = await db.execute(`
-    SELECT COUNT(*) as count 
-    FROM pragma_table_info('agent_history') 
-    WHERE name = 'workflow_id'
-  `);
-  if (checkWorkflowIdColumn.rows[0].count === 0) {
-    await db.execute("ALTER TABLE agent_history ADD COLUMN workflow_id TEXT");
-  }
-  const checkWorkflowStepIdColumn = await db.execute(`
-    SELECT COUNT(*) as count 
-    FROM pragma_table_info('agent_history') 
-    WHERE name = 'workflow_step_id'
-  `);
-  if (checkWorkflowStepIdColumn.rows[0].count === 0) {
-    await db.execute("ALTER TABLE agent_history ADD COLUMN workflow_step_id TEXT");
-  }
-  await db.execute(
-    "CREATE INDEX IF NOT EXISTS idx_agent_history_workflow_id ON agent_history(workflow_id)"
-  );
-  await db.execute(
-    "CREATE INDEX IF NOT EXISTS idx_agent_history_workflow_step ON agent_history(workflow_step_id)"
-  );
-}
-__name(createWorkflowTables, "createWorkflowTables");
-
-// src/workflow-extension.ts
-import { safeStringify } from "@voltagent/internal/utils";
-import { createPinoLogger } from "@voltagent/logger";
-var LibSQLWorkflowExtension = class {
-  constructor(client, _tablePrefix = "voltagent_memory", logger) {
-    this.client = client;
-    this._tablePrefix = _tablePrefix;
-    this.logger = logger || createPinoLogger({ name: "libsql-workflow" });
+  /**
+   * 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
+   */
+  async addV2ColumnsToMessagesTable() {
+    const messagesTableName = `${this.tablePrefix}_messages`;
+    try {
+      const tableInfo = await this.client.execute(`PRAGMA table_info(${messagesTableName})`);
+      const columns = tableInfo.rows.map((row) => row.name);
+      if (!columns.includes("parts")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN parts TEXT`);
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("metadata")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN metadata TEXT`);
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("format_version")) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN format_version INTEGER DEFAULT 2`
+          );
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("user_id")) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN user_id TEXT NOT NULL DEFAULT 'default'`
+          );
+        } catch (_e) {
+        }
+      }
+      const contentInfo = tableInfo.rows.find((row) => row.name === "content");
+      if (contentInfo && contentInfo.notnull === 1) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN content_temp TEXT`
+          );
+          await this.client.execute(
+            `UPDATE ${messagesTableName} SET content_temp = content WHERE content IS NOT NULL`
+          );
+          try {
+            await this.client.execute(`ALTER TABLE ${messagesTableName} DROP COLUMN content`);
+            await this.client.execute(
+              `ALTER TABLE ${messagesTableName} RENAME COLUMN content_temp TO content`
+            );
+          } catch (_) {
+          }
+        } catch (_) {
+        }
+      }
+      const typeInfo = tableInfo.rows.find((row) => row.name === "type");
+      if (typeInfo && typeInfo.notnull === 1) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN type_temp TEXT`);
+          await this.client.execute(
+            `UPDATE ${messagesTableName} SET type_temp = type WHERE type IS NOT NULL`
+          );
+          try {
+            await this.client.execute(`ALTER TABLE ${messagesTableName} DROP COLUMN type`);
+            await this.client.execute(
+              `ALTER TABLE ${messagesTableName} RENAME COLUMN type_temp TO type`
+            );
+          } catch (_) {
+          }
+        } catch (_) {
+        }
+      }
+    } catch (_) {
+    }
   }
-  static {
-    __name(this, "LibSQLWorkflowExtension");
+  /**
+   * Migrate default user_id values in messages table
+   * Updates messages with user_id='default' to use the actual user_id from their conversation
+   */
+  async migrateDefaultUserIds() {
+    const messagesTableName = `${this.tablePrefix}_messages`;
+    const conversationsTableName = `${this.tablePrefix}_conversations`;
+    try {
+      const checkResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${messagesTableName} WHERE user_id = 'default'`,
+        args: []
+      });
+      const defaultCount = checkResult.rows[0]?.count || 0;
+      if (defaultCount === 0) {
+        return;
+      }
+      this.logger.debug(`Found ${defaultCount} messages with default user_id, starting migration`);
+      await this.executeWithRetry(async () => {
+        const result = await this.client.execute({
+          sql: `UPDATE ${messagesTableName}
+                SET user_id = (
+                  SELECT c.user_id 
+                  FROM ${conversationsTableName} c 
+                  WHERE c.id = ${messagesTableName}.conversation_id
+                )
+                WHERE user_id = 'default'
+                AND EXISTS (
+                  SELECT 1 
+                  FROM ${conversationsTableName} c 
+                  WHERE c.id = ${messagesTableName}.conversation_id
+                )`,
+          args: []
+        });
+        const updatedCount = result.rowsAffected || 0;
+        this.logger.info(
+          `Successfully migrated ${updatedCount} messages from default user_id to actual user_ids`
+        );
+        const remainingResult = await this.client.execute({
+          sql: `SELECT COUNT(*) as count FROM ${messagesTableName} WHERE user_id = 'default'`,
+          args: []
+        });
+        const remainingCount = remainingResult.rows[0]?.count || 0;
+        if (remainingCount > 0) {
+          this.logger.warn(
+            `${remainingCount} messages still have default user_id (possibly orphaned messages without valid conversations)`
+          );
+        }
+      }, "migrate default user_ids");
+    } catch (error) {
+      this.logger.error("Failed to migrate default user_ids", error);
+    }
   }
-  logger;
+  // ============================================================================
+  // Message Operations
+  // ============================================================================
   /**
-   * Store a workflow history entry
+   * Add a single message
    */
-  async storeWorkflowHistory(entry) {
-    await this.client.execute({
-      sql: `
-        INSERT INTO ${this._tablePrefix}_workflow_history (
-          id, name, workflow_id, status, start_time, end_time, 
-          input, output, user_id, conversation_id, metadata, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      args: [
-        entry.id,
-        entry.workflowName,
-        entry.workflowId,
-        entry.status,
-        entry.startTime.toISOString(),
-        entry.endTime?.toISOString() || null,
-        safeStringify(entry.input),
-        entry.output ? safeStringify(entry.output) : null,
-        entry.userId || null,
-        entry.conversationId || null,
-        entry.metadata ? safeStringify(entry.metadata) : null,
-        entry.createdAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString(),
-        entry.updatedAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString()
-      ]
-    });
+  async addMessage(message, userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversation = await this.getConversation(conversationId);
+    if (!conversation) {
+      throw new ConversationNotFoundError(conversationId);
+    }
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `INSERT INTO ${messagesTable} (conversation_id, message_id, user_id, role, parts, metadata, format_version, created_at) 
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          conversationId,
+          message.id,
+          userId,
+          message.role,
+          JSON.stringify(message.parts),
+          message.metadata ? JSON.stringify(message.metadata) : null,
+          2,
+          // format_version
+          (/* @__PURE__ */ new Date()).toISOString()
+        ]
+      });
+    }, "add message");
+    await this.applyStorageLimit(conversationId);
   }
   /**
-   * Get a workflow history entry by ID
+   * Add multiple messages
    */
-  async getWorkflowHistory(id) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_history WHERE id = ?`,
-      args: [id]
-    });
-    if (result.rows.length === 0) return null;
-    return this.parseWorkflowHistoryRow(result.rows[0]);
+  async addMessages(messages, userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversation = await this.getConversation(conversationId);
+    if (!conversation) {
+      throw new ConversationNotFoundError(conversationId);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.executeWithRetry(async () => {
+      await this.client.batch(
+        messages.map((message) => ({
+          sql: `INSERT INTO ${messagesTable} (conversation_id, message_id, user_id, role, parts, metadata, format_version, created_at) 
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            conversationId,
+            message.id,
+            userId,
+            message.role,
+            JSON.stringify(message.parts),
+            message.metadata ? JSON.stringify(message.metadata) : null,
+            2,
+            // format_version
+            now
+          ]
+        }))
+      );
+    }, "add batch messages");
+    await this.applyStorageLimit(conversationId);
   }
   /**
-   * Get all workflow history entries for a specific workflow
+   * Apply storage limit to a conversation
    */
-  async getWorkflowHistoryByWorkflowId(workflowId) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_history WHERE workflow_id = ? ORDER BY start_time DESC`,
-      args: [workflowId]
-    });
-    return result.rows.map((row) => this.parseWorkflowHistoryRow(row));
+  async applyStorageLimit(conversationId) {
+    const messagesTable = `${this.tablePrefix}_messages`;
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `DELETE FROM ${messagesTable}
+            WHERE conversation_id = ? 
+            AND message_id NOT IN (
+              SELECT message_id FROM ${messagesTable}
+              WHERE conversation_id = ? 
+              ORDER BY created_at DESC 
+              LIMIT ?
+            )`,
+        args: [conversationId, conversationId, this.storageLimit]
+      });
+    }, "apply storage limit");
   }
   /**
-   * Update a workflow history entry
+   * Get messages with optional filtering
    */
-  async updateWorkflowHistory(id, updates) {
-    this.logger.trace(`Updating workflow history ${id}`, {
-      status: updates.status,
-      hasMetadata: !!updates.metadata,
-      hasSuspension: !!updates.metadata?.suspension
-    });
-    const setClauses = [];
-    const args = [];
-    if (updates.status !== void 0) {
-      setClauses.push("status = ?");
-      args.push(updates.status);
+  async getMessages(userId, conversationId, options) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const { limit = this.storageLimit, before, after, roles } = options || {};
+    let sql = `SELECT * FROM ${messagesTable}
+               WHERE conversation_id = ? AND user_id = ?`;
+    const args = [conversationId, userId];
+    if (roles && roles.length > 0) {
+      const placeholders = roles.map(() => "?").join(",");
+      sql += ` AND role IN (${placeholders})`;
+      args.push(...roles);
     }
-    if (updates.endTime !== void 0) {
-      setClauses.push("end_time = ?");
-      args.push(updates.endTime.toISOString());
+    if (before) {
+      sql += " AND created_at < ?";
+      args.push(before.toISOString());
     }
-    if (updates.output !== void 0) {
-      setClauses.push("output = ?");
-      args.push(safeStringify(updates.output));
-    }
-    if (updates.userId !== void 0) {
-      setClauses.push("user_id = ?");
-      args.push(updates.userId);
-    }
-    if (updates.conversationId !== void 0) {
-      setClauses.push("conversation_id = ?");
-      args.push(updates.conversationId);
-    }
-    if (updates.metadata !== void 0) {
-      setClauses.push("metadata = ?");
-      const metadataJson = safeStringify(updates.metadata);
-      args.push(metadataJson);
-      this.logger.trace(`Setting metadata for ${id}:`, { metadata: metadataJson });
+    if (after) {
+      sql += " AND created_at > ?";
+      args.push(after.toISOString());
     }
-    setClauses.push("updated_at = ?");
-    args.push((/* @__PURE__ */ new Date()).toISOString());
-    args.push(id);
-    const sql = `UPDATE ${this._tablePrefix}_workflow_history SET ${setClauses.join(", ")} WHERE id = ?`;
-    this.logger.trace("Executing SQL:", { sql, args });
-    try {
-      const result = await this.client.execute({ sql, args });
-      this.logger.trace(
-        `Successfully updated workflow history ${id}, rows affected: ${result.rowsAffected}`
-      );
-    } catch (error) {
-      this.logger.error(`Failed to update workflow history ${id}:`, { error });
-      throw error;
+    sql += " ORDER BY created_at ASC";
+    if (limit && limit > 0) {
+      sql += " LIMIT ?";
+      args.push(limit);
     }
+    const result = await this.client.execute({ sql, args });
+    return result.rows.map((row) => {
+      let parts;
+      if (row.parts !== void 0 && row.parts !== null) {
+        try {
+          parts = JSON.parse(row.parts);
+        } catch {
+          parts = [];
+        }
+      } else if (row.content !== void 0 && row.content !== null) {
+        try {
+          const content = JSON.parse(row.content);
+          if (typeof content === "string") {
+            parts = [{ type: "text", text: content }];
+          } else if (Array.isArray(content)) {
+            parts = content;
+          } else {
+            parts = [];
+          }
+        } catch {
+          parts = [{ type: "text", text: row.content }];
+        }
+      } else {
+        parts = [];
+      }
+      return {
+        id: row.message_id,
+        role: row.role,
+        parts,
+        metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+      };
+    });
   }
   /**
-   * Delete a workflow history entry
+   * Clear messages for a user
    */
-  async deleteWorkflowHistory(id) {
-    await this.client.execute({
-      sql: `DELETE FROM ${this._tablePrefix}_workflow_history WHERE id = ?`,
-      args: [id]
-    });
+  async clearMessages(userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    if (conversationId) {
+      await this.client.execute({
+        sql: `DELETE FROM ${messagesTable} WHERE conversation_id = ? AND user_id = ?`,
+        args: [conversationId, userId]
+      });
+    } else {
+      await this.client.execute({
+        sql: `DELETE FROM ${messagesTable}
+              WHERE conversation_id IN (
+                SELECT id FROM ${conversationsTable} WHERE user_id = ?
+              )`,
+        args: [userId]
+      });
+    }
   }
+  // ============================================================================
+  // Conversation Operations
+  // ============================================================================
   /**
-   * Store a workflow step entry
+   * Create a new conversation
    */
-  async storeWorkflowStep(step) {
-    await this.client.execute({
-      sql: `
-        INSERT INTO ${this._tablePrefix}_workflow_steps (
-          id, workflow_history_id, step_index, step_type, step_name, step_id,
-          status, start_time, end_time, input, output, error_message,
-          agent_execution_id, parallel_index, parent_step_id, metadata,
-          created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      args: [
-        step.id,
-        step.workflowHistoryId,
-        step.stepIndex,
-        step.stepType,
-        step.stepName,
-        step.stepId || null,
-        step.status,
-        step.startTime.toISOString(),
-        step.endTime?.toISOString() || null,
-        step.input ? safeStringify(step.input) : null,
-        step.output ? safeStringify(step.output) : null,
-        step.error ? safeStringify(step.error) : null,
-        step.agentExecutionId || null,
-        step.parallelIndex || null,
-        step.parallelParentStepId || null,
-        step.metadata ? safeStringify(step.metadata) : null,
-        step.createdAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString(),
-        step.updatedAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString()
-      ]
-    });
+  async createConversation(input) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const existing = await this.getConversation(input.id);
+    if (existing) {
+      throw new ConversationAlreadyExistsError(input.id);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `INSERT INTO ${conversationsTable} (id, resource_id, user_id, title, metadata, created_at, updated_at) 
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          input.id,
+          input.resourceId,
+          input.userId,
+          input.title,
+          JSON.stringify(input.metadata || {}),
+          now,
+          now
+        ]
+      });
+    }, "create conversation");
+    return {
+      id: input.id,
+      userId: input.userId,
+      resourceId: input.resourceId,
+      title: input.title,
+      metadata: input.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
   }
   /**
-   * Get a workflow step by ID
+   * Get a conversation by ID
    */
-  async getWorkflowStep(id) {
+  async getConversation(id) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
     const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_steps WHERE id = ?`,
+      sql: `SELECT * FROM ${conversationsTable} WHERE id = ?`,
       args: [id]
     });
-    if (result.rows.length === 0) return null;
-    return this.parseWorkflowStepRow(result.rows[0]);
+    if (result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
   }
   /**
-   * Get all workflow steps for a specific workflow history
+   * Get conversations by resource ID
    */
-  async getWorkflowSteps(workflowHistoryId) {
+  async getConversations(resourceId) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
     const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_steps WHERE workflow_history_id = ? ORDER BY step_index ASC`,
-      args: [workflowHistoryId]
+      sql: `SELECT * FROM ${conversationsTable} WHERE resource_id = ? ORDER BY updated_at DESC`,
+      args: [resourceId]
     });
-    return result.rows.map((row) => this.parseWorkflowStepRow(row));
+    return result.rows.map((row) => ({
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
   }
   /**
-   * Update a workflow step
+   * Get conversations by user ID
    */
-  async updateWorkflowStep(id, updates) {
-    const setClauses = [];
+  async getConversationsByUserId(userId, options) {
+    return this.queryConversations({ ...options, userId });
+  }
+  /**
+   * Query conversations with filters
+   */
+  async queryConversations(options) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    let sql = `SELECT * FROM ${conversationsTable} WHERE 1=1`;
     const args = [];
-    if (updates.status !== void 0) {
-      setClauses.push("status = ?");
-      args.push(updates.status);
+    if (options.userId) {
+      sql += " AND user_id = ?";
+      args.push(options.userId);
     }
-    if (updates.endTime !== void 0) {
-      setClauses.push("end_time = ?");
-      args.push(updates.endTime.toISOString());
+    if (options.resourceId) {
+      sql += " AND resource_id = ?";
+      args.push(options.resourceId);
     }
-    if (updates.output !== void 0) {
-      setClauses.push("output = ?");
-      args.push(safeStringify(updates.output));
+    const orderBy = options.orderBy || "updated_at";
+    const orderDirection = options.orderDirection || "DESC";
+    sql += ` ORDER BY ${orderBy} ${orderDirection}`;
+    if (options.limit) {
+      sql += " LIMIT ?";
+      args.push(options.limit);
     }
-    if (updates.error !== void 0) {
-      setClauses.push("error_message = ?");
-      args.push(safeStringify(updates.error));
+    if (options.offset) {
+      sql += " OFFSET ?";
+      args.push(options.offset);
     }
-    if (updates.agentExecutionId !== void 0) {
-      setClauses.push("agent_execution_id = ?");
-      args.push(updates.agentExecutionId);
+    const result = await this.client.execute({ sql, args });
+    return result.rows.map((row) => ({
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  /**
+   * Update a conversation
+   */
+  async updateConversation(id, updates) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const conversation = await this.getConversation(id);
+    if (!conversation) {
+      throw new ConversationNotFoundError(id);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fieldsToUpdate = ["updated_at = ?"];
+    const args = [now];
+    if (updates.title !== void 0) {
+      fieldsToUpdate.push("title = ?");
+      args.push(updates.title);
+    }
+    if (updates.resourceId !== void 0) {
+      fieldsToUpdate.push("resource_id = ?");
+      args.push(updates.resourceId);
     }
     if (updates.metadata !== void 0) {
-      setClauses.push("metadata = ?");
-      args.push(safeStringify(updates.metadata));
+      fieldsToUpdate.push("metadata = ?");
+      args.push(JSON.stringify(updates.metadata));
     }
-    setClauses.push("updated_at = ?");
-    args.push((/* @__PURE__ */ new Date()).toISOString());
     args.push(id);
     await this.client.execute({
-      sql: `UPDATE ${this._tablePrefix}_workflow_steps SET ${setClauses.join(", ")} WHERE id = ?`,
+      sql: `UPDATE ${conversationsTable} SET ${fieldsToUpdate.join(", ")} WHERE id = ?`,
       args
     });
+    const updated = await this.getConversation(id);
+    if (!updated) {
+      throw new Error(`Conversation not found after update: ${id}`);
+    }
+    return updated;
   }
   /**
-   * Delete a workflow step
-   */
-  async deleteWorkflowStep(id) {
-    await this.client.execute({
-      sql: `DELETE FROM ${this._tablePrefix}_workflow_steps WHERE id = ?`,
-      args: [id]
-    });
-  }
-  /**
-   * Store a workflow timeline event
+   * Delete a conversation
    */
-  async storeWorkflowTimelineEvent(event) {
+  async deleteConversation(id) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
     await this.client.execute({
-      sql: `
-        INSERT INTO ${this._tablePrefix}_workflow_timeline_events (
-          id, workflow_history_id, event_id, name, type,
-          start_time, end_time, status, level, input, output,
-          status_message, metadata, trace_id, parent_event_id, event_sequence, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      args: [
-        event.id,
-        event.workflowHistoryId,
-        event.eventId,
-        event.name,
-        event.type,
-        event.startTime,
-        event.endTime || null,
-        event.status,
-        event.level || "INFO",
-        event.input ? safeStringify(event.input) : null,
-        event.output ? safeStringify(event.output) : null,
-        event.statusMessage ? safeStringify(event.statusMessage) : null,
-        event.metadata ? safeStringify(event.metadata) : null,
-        event.traceId || null,
-        event.parentEventId || null,
-        event.eventSequence || null,
-        // Event sequence for ordering
-        event.createdAt.toISOString()
-      ]
-    });
-  }
-  /**
-   * Get a workflow timeline event by ID
-   */
-  async getWorkflowTimelineEvent(id) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_timeline_events WHERE id = ?`,
+      sql: `DELETE FROM ${conversationsTable} WHERE id = ?`,
       args: [id]
     });
-    if (result.rows.length === 0) return null;
-    return this.parseWorkflowTimelineEventRow(result.rows[0]);
   }
+  // ============================================================================
+  // Working Memory Operations
+  // ============================================================================
   /**
-   * Get all workflow timeline events for a specific workflow history
+   * Get working memory
    */
-  async getWorkflowTimelineEvents(workflowHistoryId) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${this._tablePrefix}_workflow_timeline_events WHERE workflow_history_id = ? ORDER BY event_sequence ASC, start_time ASC`,
-      args: [workflowHistoryId]
-    });
-    return result.rows.map((row) => this.parseWorkflowTimelineEventRow(row));
+  async getWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      return conversation?.metadata?.workingMemory || null;
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0) {
+        const metadata = result.rows[0].metadata ? JSON.parse(result.rows[0].metadata) : {};
+        return metadata.workingMemory || null;
+      }
+    }
+    return null;
   }
   /**
-   * Delete a workflow timeline event
+   * Set working memory
    */
-  async deleteWorkflowTimelineEvent(id) {
-    await this.client.execute({
-      sql: `DELETE FROM ${this._tablePrefix}_workflow_timeline_events WHERE id = ?`,
-      args: [id]
-    });
+  async setWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      if (!conversation) {
+        throw new ConversationNotFoundError(params.conversationId);
+      }
+      const metadata = conversation.metadata || {};
+      metadata.workingMemory = params.content;
+      await this.updateConversation(params.conversationId, { metadata });
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0) {
+        const metadata = result.rows[0].metadata ? JSON.parse(result.rows[0].metadata) : {};
+        metadata.workingMemory = params.content;
+        await this.client.execute({
+          sql: `UPDATE ${usersTable} SET metadata = ?, updated_at = ? WHERE id = ?`,
+          args: [JSON.stringify(metadata), now, params.userId]
+        });
+      } else {
+        await this.client.execute({
+          sql: `INSERT INTO ${usersTable} (id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+          args: [params.userId, JSON.stringify({ workingMemory: params.content }), now, now]
+        });
+      }
+    }
   }
   /**
-   * Get all workflow IDs
+   * Delete working memory
    */
-  async getAllWorkflowIds() {
-    const result = await this.client.execute({
-      sql: `SELECT DISTINCT workflow_id FROM ${this._tablePrefix}_workflow_history`,
-      args: []
-    });
-    return result.rows.map((row) => row.workflow_id);
+  async deleteWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      if (conversation?.metadata?.workingMemory) {
+        const metadata = { ...conversation.metadata };
+        delete metadata.workingMemory;
+        await this.updateConversation(params.conversationId, { metadata });
+      }
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0 && result.rows[0].metadata) {
+        const metadata = JSON.parse(result.rows[0].metadata);
+        if (metadata.workingMemory) {
+          delete metadata.workingMemory;
+          await this.client.execute({
+            sql: `UPDATE ${usersTable} SET metadata = ?, updated_at = ? WHERE id = ?`,
+            args: [JSON.stringify(metadata), (/* @__PURE__ */ new Date()).toISOString(), params.userId]
+          });
+        }
+      }
+    }
   }
+  // ============================================================================
+  // Workflow State Operations
+  // ============================================================================
   /**
-   * Get workflow statistics
+   * Get workflow state by execution ID
    */
-  async getWorkflowStats(workflowId) {
+  async getWorkflowState(executionId) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
     const result = await this.client.execute({
-      sql: `
-        SELECT 
-          COUNT(*) as total_executions,
-          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as successful_executions,
-          SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as failed_executions,
-          AVG(CASE WHEN end_time IS NOT NULL THEN 
-            (julianday(end_time) - julianday(start_time)) * 24 * 60 * 60 * 1000 
-            ELSE NULL END) as avg_duration_ms,
-          MAX(start_time) as last_execution_time
-        FROM ${this._tablePrefix}_workflow_history 
-        WHERE workflow_id = ?
-      `,
-      args: [workflowId]
+      sql: `SELECT * FROM ${workflowStatesTable} WHERE id = ?`,
+      args: [executionId]
     });
     if (result.rows.length === 0) {
-      return {
-        totalExecutions: 0,
-        successfulExecutions: 0,
-        failedExecutions: 0,
-        averageExecutionTime: 0,
-        lastExecutionTime: void 0
-      };
+      return null;
     }
     const row = result.rows[0];
     return {
-      totalExecutions: Number(row.total_executions) || 0,
-      successfulExecutions: Number(row.successful_executions) || 0,
-      failedExecutions: Number(row.failed_executions) || 0,
-      averageExecutionTime: Number(row.avg_duration_ms) || 0,
-      lastExecutionTime: row.last_execution_time ? new Date(row.last_execution_time) : void 0
-    };
-  }
+      id: row.id,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name,
+      status: row.status,
+      suspension: row.suspension ? JSON.parse(row.suspension) : void 0,
+      userId: row.user_id,
+      conversationId: row.conversation_id,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
   /**
-   * Get workflow history with all related data (steps and events)
+   * Set workflow state
    */
-  async getWorkflowHistoryWithStepsAndEvents(id) {
-    const history = await this.getWorkflowHistory(id);
-    if (!history) return null;
-    const [steps, events] = await Promise.all([
-      this.getWorkflowSteps(id),
-      this.getWorkflowTimelineEvents(id)
-    ]);
-    history.steps = steps;
-    history.events = events;
-    return history;
+  async setWorkflowState(executionId, state) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    await this.client.execute({
+      sql: `INSERT OR REPLACE INTO ${workflowStatesTable} 
+            (id, workflow_id, workflow_name, status, suspension, user_id, conversation_id, metadata, created_at, updated_at) 
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        executionId,
+        state.workflowId,
+        state.workflowName,
+        state.status,
+        state.suspension ? JSON.stringify(state.suspension) : null,
+        state.userId || null,
+        state.conversationId || null,
+        state.metadata ? JSON.stringify(state.metadata) : null,
+        state.createdAt.toISOString(),
+        state.updatedAt.toISOString()
+      ]
+    });
   }
   /**
-   * Delete workflow history and all related data
+   * Update workflow state
    */
-  async deleteWorkflowHistoryWithRelated(id) {
-    await this.deleteWorkflowHistory(id);
+  async updateWorkflowState(executionId, updates) {
+    await this.initialize();
+    const existing = await this.getWorkflowState(executionId);
+    if (!existing) {
+      throw new Error(`Workflow state ${executionId} not found`);
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.setWorkflowState(executionId, updated);
   }
   /**
-   * Clean up old workflow histories
+   * Get suspended workflow states for a workflow
    */
-  async cleanupOldWorkflowHistories(workflowId, maxEntries) {
-    const countResult = await this.client.execute({
-      sql: `SELECT COUNT(*) as count FROM ${this._tablePrefix}_workflow_history WHERE workflow_id = ?`,
+  async getSuspendedWorkflowStates(workflowId) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${workflowStatesTable} WHERE workflow_id = ? AND status = 'suspended' ORDER BY created_at DESC`,
       args: [workflowId]
     });
-    const currentCount = Number(countResult.rows[0].count);
-    if (currentCount <= maxEntries) return 0;
-    const deleteCount = currentCount - maxEntries;
-    const deleteResult = await this.client.execute({
-      sql: `
-        DELETE FROM ${this._tablePrefix}_workflow_history 
-        WHERE workflow_id = ? 
-        AND id IN (
-          SELECT id FROM ${this._tablePrefix}_workflow_history 
-          WHERE workflow_id = ? 
-          ORDER BY start_time ASC 
-          LIMIT ?
-        )
-      `,
-      args: [workflowId, workflowId, deleteCount]
-    });
-    return deleteResult.rowsAffected;
-  }
-  /**
-   * Parse workflow history row from database
-   */
-  parseWorkflowHistoryRow(row) {
-    return {
+    return result.rows.map((row) => ({
       id: row.id,
-      workflowName: row.name,
       workflowId: row.workflow_id,
-      status: row.status,
-      startTime: new Date(row.start_time),
-      endTime: row.end_time ? new Date(row.end_time) : void 0,
-      input: row.input ? JSON.parse(row.input) : null,
-      output: row.output ? JSON.parse(row.output) : void 0,
+      workflowName: row.workflow_name,
+      status: "suspended",
+      suspension: row.suspension ? JSON.parse(row.suspension) : void 0,
       userId: row.user_id,
       conversationId: row.conversation_id,
       metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      steps: [],
-      // Will be loaded separately if needed
-      events: [],
-      // Will be loaded separately if needed
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
-    };
-  }
-  /**
-   * Parse workflow step row from database
-   */
-  parseWorkflowStepRow(row) {
-    return {
-      id: row.id,
-      workflowHistoryId: row.workflow_history_id,
-      stepIndex: Number(row.step_index),
-      stepType: row.step_type,
-      stepName: row.step_name,
-      stepId: row.step_id || void 0,
-      status: row.status,
-      startTime: new Date(row.start_time),
-      endTime: row.end_time ? new Date(row.end_time) : void 0,
-      input: row.input ? JSON.parse(row.input) : void 0,
-      output: row.output ? JSON.parse(row.output) : void 0,
-      error: row.error_message ? JSON.parse(row.error_message) : void 0,
-      agentExecutionId: row.agent_execution_id || void 0,
-      parallelIndex: row.parallel_index ? Number(row.parallel_index) : void 0,
-      parallelParentStepId: row.parent_step_id || void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
       createdAt: new Date(row.created_at),
       updatedAt: new Date(row.updated_at)
-    };
+    }));
   }
   /**
-   * Parse workflow timeline event row from database
+   * Close database connection
    */
-  parseWorkflowTimelineEventRow(row) {
-    return {
-      id: row.id,
-      workflowHistoryId: row.workflow_history_id,
-      eventId: row.event_id,
-      name: row.name,
-      type: row.type,
-      startTime: row.start_time,
-      endTime: row.end_time ? row.end_time : void 0,
-      status: row.status,
-      level: row.level || void 0,
-      input: row.input ? JSON.parse(row.input) : void 0,
-      output: row.output ? JSON.parse(row.output) : void 0,
-      statusMessage: row.status_message ? JSON.parse(row.status_message) : void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      traceId: row.trace_id || void 0,
-      parentEventId: row.parent_event_id || void 0,
-      eventSequence: Number(row.event_sequence),
-      createdAt: new Date(row.created_at)
-    };
+  async close() {
+    this.logger.debug("Closing LibSQL Memory adapter");
   }
 };
 
-// src/index.ts
-async function debugDelay() {
-  const min = 0;
-  const max = 0;
-  const delay = Math.floor(Math.random() * (max - min + 1)) + min;
-  return new Promise((resolve) => setTimeout(resolve, delay));
-}
-__name(debugDelay, "debugDelay");
-var LibSQLStorage = class {
+// src/observability-adapter.ts
+import { existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { createClient as createClient2 } from "@libsql/client";
+import { safeStringify } from "@voltagent/internal/utils";
+import { createPinoLogger as createPinoLogger2 } from "@voltagent/logger";
+var LibSQLObservabilityAdapter = class {
   static {
-    __name(this, "LibSQLStorage");
+    __name(this, "LibSQLObservabilityAdapter");
   }
   client;
-  options;
-  initialized;
-  workflowExtension;
+  tablePrefix;
+  debug;
   logger;
-  retryAttempts;
-  baseDelayMs;
-  /**
-   * Create a new LibSQL storage
-   * @param options Configuration options
-   */
-  constructor(options) {
-    this.logger = options.logger || createPinoLogger2({ name: "libsql-storage" });
-    this.retryAttempts = options.retryAttempts ?? 3;
-    this.baseDelayMs = options.baseDelayMs ?? 50;
-    this.options = {
-      storageLimit: options.storageLimit || 100,
-      tablePrefix: options.tablePrefix || "voltagent_memory",
-      debug: options.debug || false,
-      url: options.url || "file:./.voltagent/memory.db",
-      authToken: options.authToken,
-      retryAttempts: this.retryAttempts,
-      baseDelayMs: this.baseDelayMs
-    };
-    if (this.options.url.startsWith("file:") && !this.options.url.includes(":memory:")) {
-      const filePath = this.options.url.substring(5);
+  initialized;
+  maxSpansPerQuery;
+  constructor(options = {}) {
+    this.logger = options.logger || createPinoLogger2({ name: "libsql-observability" });
+    this.tablePrefix = options.tablePrefix || "observability";
+    this.debug = options.debug || false;
+    this.maxSpansPerQuery = options.maxSpansPerQuery || 1e3;
+    const url = options.url || "file:./.voltagent/observability.db";
+    if (url.startsWith("file:") && !url.includes(":memory:")) {
+      const filePath = url.substring(5);
       const dir = dirname(filePath);
       if (dir && dir !== "." && !existsSync(dir)) {
         try {
           mkdirSync(dir, { recursive: true });
-          this.debug("Created directory for database", { dir });
+          this.debugLog("Created directory for database", { dir });
         } catch (error) {
           this.logger.warn("Failed to create directory for database", { dir, error });
         }
       }
     }
-    this.client = createClient({
-      url: this.options.url,
-      authToken: this.options.authToken
+    this.client = createClient2({
+      url,
+      authToken: options.authToken
+    });
+    this.debugLog("LibSQL observability adapter initialized with options", {
+      url,
+      tablePrefix: this.tablePrefix,
+      debug: this.debug,
+      maxSpansPerQuery: this.maxSpansPerQuery
     });
-    this.debug("LibSQL storage provider initialized with options", this.options);
-    this.workflowExtension = new LibSQLWorkflowExtension(
-      this.client,
-      this.options.tablePrefix,
-      this.logger
-    );
     this.initialized = this.initializeDatabase();
   }
   /**
    * Log a debug message if debug is enabled
-   * @param message Message to log
-   * @param data Additional data to log
    */
-  debug(message, data) {
-    if (this.options?.debug) {
+  debugLog(message, data) {
+    if (this.debug) {
       this.logger.debug(`${message}`, data || "");
     }
   }
   /**
-   * Calculate delay with jitter for better load distribution
-   * @param attempt Current retry attempt number
-   * @returns Delay in milliseconds
-   */
-  calculateRetryDelay(attempt) {
-    const exponentialDelay = this.baseDelayMs * 2 ** (attempt - 1);
-    const jitterFactor = 0.2 + Math.random() * 0.2;
-    const delayWithJitter = exponentialDelay * (1 + jitterFactor);
-    return Math.min(delayWithJitter, 2e3);
-  }
-  /**
-   * 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
-   */
-  async executeWithRetryStrategy(operationFn, operationName) {
-    let attempt = 0;
-    while (attempt < this.retryAttempts) {
-      attempt++;
-      try {
-        return await operationFn();
-      } catch (error) {
-        const isBusyError = error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked") || error.code === "SQLITE_BUSY");
-        if (!isBusyError || attempt >= this.retryAttempts) {
-          this.debug(`Operation failed: ${operationName}`, {
-            attempt,
-            error: error.message
-          });
-          throw error;
-        }
-        const delay = this.calculateRetryDelay(attempt);
-        this.debug(`Retrying ${operationName}`, {
-          attempt,
-          remainingAttempts: this.retryAttempts - attempt,
-          delay
-        });
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-    throw new Error(`Max retry attempts (${this.retryAttempts}) exceeded for ${operationName}`);
-  }
-  /**
-   * Initialize workflow tables
-   */
-  async initializeWorkflowTables() {
-    try {
-      await createWorkflowTables(this.client, this.options.tablePrefix);
-      this.debug("Workflow tables initialized successfully");
-      await addSuspendedStatusMigration(this.client, this.options.tablePrefix);
-      this.debug("Workflow migrations applied successfully");
-    } catch (error) {
-      this.debug("Error initializing workflow tables:", error);
-    }
-  }
-  /**
-   * Initialize the database tables
-   * @returns Promise that resolves when initialization is complete
+   * Initialize database tables for observability
    */
   async initializeDatabase() {
-    if (this.options.url.startsWith("file:") || this.options.url.includes(":memory:")) {
-      try {
-        await this.client.execute("PRAGMA journal_mode=WAL;");
-        this.debug("PRAGMA journal_mode=WAL set.");
-      } catch (err) {
-        this.debug("Failed to set PRAGMA journal_mode=WAL.", err);
-      }
-      try {
-        await this.client.execute("PRAGMA busy_timeout = 5000;");
-        this.debug("PRAGMA busy_timeout=5000 set.");
-      } catch (err) {
-        this.debug("Failed to set PRAGMA busy_timeout.", err);
-      }
-    }
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
-    await this.client.execute(`
-        CREATE TABLE IF NOT EXISTS ${conversationsTableName} (
-          id TEXT PRIMARY KEY,
-          resource_id TEXT NOT NULL,
-          user_id TEXT NOT NULL,
-          title TEXT NOT NULL,
-          metadata TEXT NOT NULL,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
+    try {
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_spans (
+          span_id TEXT PRIMARY KEY,
+          trace_id TEXT NOT NULL,
+          parent_span_id TEXT,
+          entity_id TEXT,
+          entity_type TEXT,
+          name TEXT NOT NULL,
+          kind INTEGER DEFAULT 0,
+          start_time TEXT NOT NULL,
+          end_time TEXT,
+          duration REAL,
+          status_code INTEGER DEFAULT 0,
+          status_message TEXT,
+          attributes TEXT,
+          events TEXT,
+          links TEXT,
+          resource TEXT,
+          instrumentation_scope TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
         )
       `);
-    const messagesTableName = `${this.options.tablePrefix}_messages`;
-    await this.client.execute(`
-        CREATE TABLE IF NOT EXISTS ${messagesTableName} (
-          conversation_id TEXT NOT NULL,
-          message_id TEXT NOT NULL,
-          role TEXT NOT NULL,
-          content TEXT NOT NULL,
-          type TEXT NOT NULL,
-          created_at TEXT NOT NULL,
-          PRIMARY KEY (conversation_id, message_id)
-        )
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_trace_id 
+        ON ${this.tablePrefix}_spans(trace_id)
       `);
-    const historyTableName = `${this.options.tablePrefix}_agent_history`;
-    await this.client.execute(`
-        CREATE TABLE IF NOT EXISTS ${historyTableName} (
-          id TEXT PRIMARY KEY,
-          agent_id TEXT NOT NULL,
-          timestamp TEXT NOT NULL,
-          status TEXT,
-          input TEXT,
-          output TEXT,
-          usage TEXT,
-          metadata TEXT,
-          userId TEXT,
-          conversationId TEXT
-        )
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_parent_span_id 
+        ON ${this.tablePrefix}_spans(parent_span_id)
       `);
-    const historyStepsTableName = `${this.options.tablePrefix}_agent_history_steps`;
-    await this.client.execute(`
-        CREATE TABLE IF NOT EXISTS ${historyStepsTableName} (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          history_id TEXT NOT NULL,
-          agent_id TEXT
-        )
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_start_time 
+        ON ${this.tablePrefix}_spans(start_time)
       `);
-    const timelineEventsTableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
-    await this.client.execute(`
-        CREATE TABLE IF NOT EXISTS ${timelineEventsTableName} (
-          id TEXT PRIMARY KEY,
-          history_id TEXT NOT NULL,
-          agent_id TEXT,
-          event_type TEXT NOT NULL,
-          event_name TEXT NOT NULL,
-          start_time TEXT NOT NULL,
-          end_time TEXT,
-          status TEXT,
-          status_message TEXT,
-          level TEXT,
-          version TEXT,
-          parent_event_id TEXT,
-          tags TEXT,
-          input TEXT,
-          output TEXT,
-          error TEXT,
-          metadata TEXT
-        )
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_name 
+        ON ${this.tablePrefix}_spans(name)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${messagesTableName}_lookup
-        ON ${messagesTableName}(conversation_id, created_at)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_entity_id 
+        ON ${this.tablePrefix}_spans(entity_id)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${conversationsTableName}_resource
-        ON ${conversationsTableName}(resource_id)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_entity_type 
+        ON ${this.tablePrefix}_spans(entity_type)
       `);
-    try {
-      const tableInfo = await this.client.execute(`PRAGMA table_info(${conversationsTableName})`);
-      const hasUserIdColumn = tableInfo.rows.some((row) => row.name === "user_id");
-      if (hasUserIdColumn) {
-        await this.client.execute(`
-          CREATE INDEX IF NOT EXISTS idx_${conversationsTableName}_user
-          ON ${conversationsTableName}(user_id)
-        `);
-      }
-    } catch (error) {
-      this.debug("Error creating user_id index, will be created after migration:", error);
-    }
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${historyStepsTableName}_history_id 
-        ON ${historyStepsTableName}(history_id)
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_traces (
+          trace_id TEXT PRIMARY KEY,
+          root_span_id TEXT,
+          entity_id TEXT,
+          entity_type TEXT,
+          start_time TEXT NOT NULL,
+          end_time TEXT,
+          span_count INTEGER DEFAULT 1,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
       `);
-    await this.initializeWorkflowTables();
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${historyTableName}_agent_id 
-        ON ${historyTableName}(agent_id)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_start_time 
+        ON ${this.tablePrefix}_traces(start_time DESC)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${historyStepsTableName}_agent_id 
-        ON ${historyStepsTableName}(agent_id)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_entity_id 
+        ON ${this.tablePrefix}_traces(entity_id)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_history_id 
-        ON ${timelineEventsTableName}(history_id)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_entity_type 
+        ON ${this.tablePrefix}_traces(entity_type)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_agent_id 
-        ON ${timelineEventsTableName}(agent_id)
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp TEXT NOT NULL,
+          trace_id TEXT,
+          span_id TEXT,
+          trace_flags INTEGER,
+          severity_number INTEGER,
+          severity_text TEXT,
+          body TEXT NOT NULL,
+          attributes TEXT,
+          resource TEXT,
+          instrumentation_scope TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_event_type 
-        ON ${timelineEventsTableName}(event_type)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_trace_id 
+        ON ${this.tablePrefix}_logs(trace_id)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_event_name 
-        ON ${timelineEventsTableName}(event_name)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_span_id 
+        ON ${this.tablePrefix}_logs(span_id)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_parent_event_id 
-        ON ${timelineEventsTableName}(parent_event_id)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_timestamp 
+        ON ${this.tablePrefix}_logs(timestamp DESC)
       `);
-    await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${timelineEventsTableName}_status 
-        ON ${timelineEventsTableName}(status)
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_severity 
+        ON ${this.tablePrefix}_logs(severity_number)
       `);
-    this.debug("Database initialized successfully");
-    try {
-      const migrationResult = await this.migrateConversationSchema({
-        createBackup: true,
-        deleteBackupAfterSuccess: true
-      });
-      if (migrationResult.success) {
-        if ((migrationResult.migratedCount || 0) > 0) {
-          this.logger.info(
-            `${migrationResult.migratedCount} conversation records successfully migrated`
-          );
-        }
-      } else {
-        this.logger.error("Conversation migration error:", migrationResult.error);
-      }
-    } catch (error) {
-      this.debug("Error migrating conversation schema:", error);
-    }
-    try {
-      const migrationResult = await this.migrateAgentHistorySchema();
-      if (!migrationResult.success) {
-        this.logger.error("Agent history schema migration error:", migrationResult.error);
-      }
+      this.debugLog("Database tables initialized successfully");
     } catch (error) {
-      this.debug("Error migrating agent history schema:", error);
+      this.logger.error("Failed to initialize database tables", { error });
+      throw error;
     }
+  }
+  /**
+   * Ensure database is initialized before operations
+   */
+  async ensureInitialized() {
+    await this.initialized;
+  }
+  /**
+   * Add a span to the database
+   */
+  async addSpan(span) {
+    await this.ensureInitialized();
     try {
-      const result = await this.migrateAgentHistoryData({
-        restoreFromBackup: false
-      });
-      if (result.success) {
-        if ((result.migratedCount || 0) > 0) {
-          this.logger.info(`${result.migratedCount} records successfully migrated`);
-        }
-      } else {
-        this.logger.error("Migration error:", result.error);
-        const restoreResult = await this.migrateAgentHistoryData({});
-        if (restoreResult.success) {
-          this.logger.info("Successfully restored from backup");
+      const entityId = span.attributes?.["entity.id"] || null;
+      const entityType = span.attributes?.["entity.type"] || null;
+      await this.client.batch([
+        // Insert the span with entity columns
+        {
+          sql: `
+            INSERT INTO ${this.tablePrefix}_spans (
+              span_id, trace_id, parent_span_id, entity_id, entity_type, name, kind,
+              start_time, end_time, duration,
+              status_code, status_message,
+              attributes, events, links,
+              resource, instrumentation_scope
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `,
+          args: [
+            span.spanId,
+            span.traceId,
+            span.parentSpanId || null,
+            entityId,
+            entityType,
+            span.name,
+            span.kind,
+            span.startTime,
+            span.endTime || null,
+            span.duration || null,
+            span.status.code,
+            span.status.message || null,
+            safeStringify(span.attributes),
+            safeStringify(span.events),
+            span.links ? safeStringify(span.links) : null,
+            span.resource ? safeStringify(span.resource) : null,
+            span.instrumentationScope ? safeStringify(span.instrumentationScope) : null
+          ]
+        },
+        // Update or insert trace metadata with entity columns
+        {
+          sql: `
+            INSERT INTO ${this.tablePrefix}_traces (
+              trace_id, root_span_id, entity_id, entity_type, start_time, end_time, span_count
+            ) VALUES (?, ?, ?, ?, ?, ?, 1)
+            ON CONFLICT(trace_id) DO UPDATE SET
+              span_count = span_count + 1,
+              entity_id = COALESCE(excluded.entity_id, entity_id),
+              entity_type = COALESCE(excluded.entity_type, entity_type),
+              start_time = MIN(start_time, excluded.start_time),
+              end_time = MAX(COALESCE(end_time, excluded.end_time), excluded.end_time),
+              updated_at = CURRENT_TIMESTAMP
+          `,
+          args: [
+            span.traceId,
+            span.parentSpanId ? null : span.spanId,
+            // Root span if no parent
+            entityId,
+            entityType,
+            span.startTime,
+            span.endTime || null
+          ]
         }
-      }
+      ]);
+      this.debugLog("Span added successfully", {
+        spanId: span.spanId,
+        traceId: span.traceId
+      });
     } catch (error) {
-      this.debug("Error initializing database:", error);
+      this.logger.error("Failed to add span", { error, span });
+      throw error;
     }
   }
   /**
-   * Generate a unique ID for a message
-   * @returns Unique ID
-   */
-  generateId() {
-    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-  }
-  /**
-   * Get messages with filtering options
-   * @param options Filtering options
-   * @returns Filtered messages
+   * Update an existing span
    */
-  async getMessages(options = {}) {
-    await this.initialized;
-    await debugDelay();
-    const {
-      userId = "default",
-      conversationId = "default",
-      limit,
-      before,
-      after,
-      role,
-      types
-    } = options;
-    const messagesTableName = `${this.options.tablePrefix}_messages`;
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
+  async updateSpan(spanId, updates) {
+    await this.ensureInitialized();
     try {
-      let sql = `
-        SELECT m.message_id, m.role, m.content, m.type, m.created_at, m.conversation_id
-        FROM ${messagesTableName} m
-      `;
+      const setClauses = [];
       const args = [];
-      const conditions = [];
-      if (userId !== "default") {
-        sql += ` INNER JOIN ${conversationsTableName} c ON m.conversation_id = c.id`;
-        conditions.push("c.user_id = ?");
-        args.push(userId);
+      if (updates.endTime !== void 0) {
+        setClauses.push("end_time = ?");
+        args.push(updates.endTime);
       }
-      if (conversationId !== "default") {
-        conditions.push("m.conversation_id = ?");
-        args.push(conversationId);
+      if (updates.duration !== void 0) {
+        setClauses.push("duration = ?");
+        args.push(updates.duration);
       }
-      if (before) {
-        conditions.push("m.created_at < ?");
-        args.push(new Date(before).toISOString());
+      if (updates.status !== void 0) {
+        setClauses.push("status_code = ?, status_message = ?");
+        args.push(updates.status.code, updates.status.message || null);
       }
-      if (after) {
-        conditions.push("m.created_at > ?");
-        args.push(new Date(after).toISOString());
+      if (updates.attributes !== void 0) {
+        setClauses.push("attributes = ?");
+        args.push(safeStringify(updates.attributes));
       }
-      if (role) {
-        conditions.push("m.role = ?");
-        args.push(role);
+      if (updates.events !== void 0) {
+        setClauses.push("events = ?");
+        args.push(safeStringify(updates.events));
       }
-      if (types) {
-        const placeholders = types.map(() => "?").join(", ");
-        conditions.push(`m.type IN (${placeholders})`);
-        args.push(...types);
-      }
-      if (conditions.length > 0) {
-        sql += ` WHERE ${conditions.join(" AND ")}`;
+      if (updates.links !== void 0) {
+        setClauses.push("links = ?");
+        args.push(safeStringify(updates.links));
       }
-      if (limit && limit > 0) {
-        sql += " ORDER BY m.created_at DESC LIMIT ?";
-        args.push(limit);
-      } else {
-        sql += " ORDER BY m.created_at ASC";
+      if (setClauses.length === 0) {
+        return;
       }
-      const result = await this.client.execute({
-        sql,
+      setClauses.push("updated_at = CURRENT_TIMESTAMP");
+      args.push(spanId);
+      await this.client.execute({
+        sql: `
+          UPDATE ${this.tablePrefix}_spans 
+          SET ${setClauses.join(", ")}
+          WHERE span_id = ?
+        `,
         args
       });
-      const messages = result.rows.map((row) => {
-        let content = row.content;
-        const parsedContent = safeJsonParse(content);
-        if (parsedContent !== null) {
-          content = parsedContent;
+      if (updates.endTime) {
+        const span = await this.getSpan(spanId);
+        if (span) {
+          await this.client.execute({
+            sql: `
+              UPDATE ${this.tablePrefix}_traces
+              SET end_time = MAX(COALESCE(end_time, ?), ?),
+                  updated_at = CURRENT_TIMESTAMP
+              WHERE trace_id = ?
+            `,
+            args: [updates.endTime, updates.endTime, span.traceId]
+          });
         }
-        return {
-          id: row.message_id,
-          role: row.role,
-          content,
-          type: row.type,
-          createdAt: row.created_at
-        };
-      });
-      if (limit && limit > 0) {
-        return messages.reverse();
       }
-      return messages;
+      this.debugLog("Span updated successfully", { spanId, updates });
     } catch (error) {
-      this.debug("Error getting messages:", error);
-      throw new Error("Failed to get messages from LibSQL database");
+      this.logger.error("Failed to update span", { error, spanId, updates });
+      throw error;
     }
   }
   /**
-   * 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")
+   * Get a span by ID
    */
-  async addMessage(message, conversationId = "default") {
-    await this.initialized;
-    await debugDelay();
-    const tableName = `${this.options.tablePrefix}_messages`;
-    const contentString = safeStringify2(message.content);
-    await this.executeWithRetryStrategy(async () => {
-      await this.client.execute({
-        sql: `INSERT INTO ${tableName} (conversation_id, message_id, role, content, type, created_at)
-              VALUES (?, ?, ?, ?, ?, ?)`,
-        args: [
-          conversationId,
-          message.id,
-          message.role,
-          contentString,
-          message.type,
-          message.createdAt
-        ]
+  async getSpan(spanId) {
+    await this.ensureInitialized();
+    try {
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_spans
+          WHERE span_id = ?
+        `,
+        args: [spanId]
       });
-      this.debug("Message added successfully", { conversationId, messageId: message.id });
-      try {
-        await this.pruneOldMessages(conversationId);
-      } catch (pruneError) {
-        this.debug("Error pruning old messages:", pruneError);
+      if (result.rows.length === 0) {
+        return null;
       }
-    }, `addMessage[${message.id}]`);
+      const row = result.rows[0];
+      return this.rowToSpan(row);
+    } catch (error) {
+      this.logger.error("Failed to get span", { error, spanId });
+      throw error;
+    }
   }
   /**
-   * Prune old messages to respect storage limit
-   * @param conversationId Conversation ID to prune messages for
+   * Get all spans in a trace
    */
-  async pruneOldMessages(conversationId) {
-    const limit = this.options.storageLimit || 100;
-    const tableName = `${this.options.tablePrefix}_messages`;
+  async getTrace(traceId) {
+    await this.ensureInitialized();
     try {
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${tableName} WHERE conversation_id = ?`,
-        args: [conversationId]
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_spans
+          WHERE trace_id = ?
+          ORDER BY start_time ASC
+          LIMIT ?
+        `,
+        args: [traceId, this.maxSpansPerQuery]
       });
-      const messageCount = countResult.rows[0]?.count;
-      if (messageCount > limit) {
-        const deleteCount = messageCount - limit;
-        await this.client.execute({
-          sql: `DELETE FROM ${tableName} 
-                WHERE conversation_id = ? 
-                AND message_id IN (
-                  SELECT message_id FROM ${tableName} 
-                  WHERE conversation_id = ? 
-                  ORDER BY created_at ASC 
-                  LIMIT ?
-                )`,
-          args: [conversationId, conversationId, deleteCount]
-        });
-        this.debug(`Pruned ${deleteCount} old messages for conversation ${conversationId}`);
-      }
+      return result.rows.map((row) => this.rowToSpan(row));
     } catch (error) {
-      this.debug("Error pruning old messages:", error);
+      this.logger.error("Failed to get trace", { error, traceId });
       throw error;
     }
   }
   /**
-   * Clear messages from memory
+   * List all traces with optional entity filter
    */
-  async clearMessages(options) {
-    await this.initialized;
-    await debugDelay();
-    const { userId, conversationId } = options;
-    const messagesTableName = `${this.options.tablePrefix}_messages`;
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
+  async listTraces(limit = 100, offset = 0, filter) {
+    await this.ensureInitialized();
     try {
-      if (conversationId) {
-        await this.client.execute({
-          sql: `DELETE FROM ${messagesTableName} 
-                WHERE conversation_id = ? 
-                AND conversation_id IN (
-                  SELECT id FROM ${conversationsTableName} WHERE user_id = ?
-                )`,
-          args: [conversationId, userId]
-        });
-        this.debug(`Cleared messages for conversation ${conversationId} for user ${userId}`);
+      let sql;
+      let args = [];
+      const conditions = [];
+      if (filter?.entityId) {
+        conditions.push("entity_id = ?");
+        args.push(filter.entityId);
+      }
+      if (filter?.entityType) {
+        conditions.push("entity_type = ?");
+        args.push(filter.entityType);
+      }
+      if (conditions.length > 0) {
+        sql = `
+          SELECT trace_id FROM ${this.tablePrefix}_traces
+          WHERE ${conditions.join(" AND ")}
+          ORDER BY start_time DESC
+          LIMIT ? OFFSET ?
+        `;
+        args.push(limit, offset);
       } else {
-        await this.client.execute({
-          sql: `DELETE FROM ${messagesTableName} 
-                WHERE conversation_id IN (
-                  SELECT id FROM ${conversationsTableName} WHERE user_id = ?
-                )`,
-          args: [userId]
-        });
-        this.debug(`Cleared all messages for user ${userId}`);
+        sql = `
+          SELECT trace_id FROM ${this.tablePrefix}_traces
+          ORDER BY start_time DESC
+          LIMIT ? OFFSET ?
+        `;
+        args = [limit, offset];
       }
+      const result = await this.client.execute({ sql, args });
+      return result.rows.map((row) => row.trace_id);
     } catch (error) {
-      this.debug("Error clearing messages:", error);
-      throw new Error("Failed to clear messages from LibSQL database");
+      this.logger.error("Failed to list traces", { error, limit, offset, filter });
+      throw error;
     }
   }
   /**
-   * Close the database connection
+   * Delete old spans
    */
-  async close() {
+  async deleteOldSpans(beforeTimestamp) {
+    await this.ensureInitialized();
     try {
-      await this.initialized;
-    } catch {
+      const beforeDate = new Date(beforeTimestamp).toISOString();
+      const tracesResult = await this.client.execute({
+        sql: `
+          SELECT DISTINCT trace_id FROM ${this.tablePrefix}_spans
+          WHERE start_time < ?
+        `,
+        args: [beforeDate]
+      });
+      const affectedTraceIds = tracesResult.rows.map((row) => row.trace_id);
+      const deleteResult = await this.client.execute({
+        sql: `
+          DELETE FROM ${this.tablePrefix}_spans
+          WHERE start_time < ?
+        `,
+        args: [beforeDate]
+      });
+      if (affectedTraceIds.length > 0) {
+        for (const traceId of affectedTraceIds) {
+          const countResult = await this.client.execute({
+            sql: `
+              SELECT COUNT(*) as count FROM ${this.tablePrefix}_spans
+              WHERE trace_id = ?
+            `,
+            args: [traceId]
+          });
+          const count = countResult.rows[0].count;
+          if (count === 0) {
+            await this.client.execute({
+              sql: `
+                DELETE FROM ${this.tablePrefix}_traces
+                WHERE trace_id = ?
+              `,
+              args: [traceId]
+            });
+          } else {
+            await this.client.execute({
+              sql: `
+                UPDATE ${this.tablePrefix}_traces
+                SET span_count = ?,
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE trace_id = ?
+              `,
+              args: [count, traceId]
+            });
+          }
+        }
+      }
+      const deletedCount = deleteResult.rowsAffected || 0;
+      this.debugLog("Old spans deleted", { deletedCount, beforeDate });
+      return deletedCount;
+    } catch (error) {
+      this.logger.error("Failed to delete old spans", { error, beforeTimestamp });
+      throw error;
     }
-    this.client.close();
   }
   /**
-   * Add or update a history entry
-   * @param key Entry ID
-   * @param value Entry data
-   * @param agentId Agent ID for filtering
+   * Clear all spans, traces, and logs
    */
-  async addHistoryEntry(key, value, agentId) {
-    await this.initialized;
+  async clear() {
+    await this.ensureInitialized();
     try {
-      const tableName = `${this.options.tablePrefix}_agent_history`;
-      const inputJSON = value.input ? safeStringify2(value.input) : null;
-      const outputJSON = value.output ? safeStringify2(value.output) : null;
-      const usageJSON = value.usage ? safeStringify2(value.usage) : null;
-      const metadataJSON = value.metadata ? safeStringify2(value.metadata) : null;
-      await this.client.execute({
-        sql: `INSERT OR REPLACE INTO ${tableName} 
-					(id, agent_id, timestamp, status, input, output, usage, metadata, userId, conversationId) 
-					VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: [
-          key,
-          // id
-          agentId,
-          // agent_id
-          value.timestamp ? value.timestamp.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
-          // timestamp
-          value.status || null,
-          // status
-          inputJSON,
-          // input
-          outputJSON,
-          // output
-          usageJSON,
-          // usage
-          metadataJSON,
-          // metadata
-          value.userId || null,
-          // userId
-          value.conversationId || null
-          // conversationId
-        ]
-      });
-      this.debug(`Set agent_history entry with ID ${key} for agent ${agentId}`);
+      await this.client.batch([
+        { sql: `DELETE FROM ${this.tablePrefix}_spans`, args: [] },
+        { sql: `DELETE FROM ${this.tablePrefix}_traces`, args: [] },
+        { sql: `DELETE FROM ${this.tablePrefix}_logs`, args: [] }
+      ]);
+      this.debugLog("All spans, traces, and logs cleared");
     } catch (error) {
-      this.debug("Error setting agent_history entry:", error);
-      throw new Error("Failed to set value in agent_history");
+      this.logger.error("Failed to clear data", { error });
+      throw error;
     }
   }
   /**
-   * Update an existing history entry
-   * @param key Entry ID
-   * @param value Updated entry data
-   * @param agentId Agent ID for filtering
+   * Convert a database row to an ObservabilitySpan
    */
-  async updateHistoryEntry(key, value, agentId) {
-    return this.addHistoryEntry(key, value, agentId);
+  rowToSpan(row) {
+    const span = {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      name: row.name,
+      kind: row.kind,
+      startTime: row.start_time,
+      status: {
+        code: row.status_code
+      },
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      events: row.events ? JSON.parse(row.events) : []
+    };
+    if (row.parent_span_id !== null) {
+      span.parentSpanId = row.parent_span_id;
+    }
+    if (row.end_time !== null) {
+      span.endTime = row.end_time;
+    }
+    if (row.duration !== null) {
+      span.duration = row.duration;
+    }
+    if (row.status_message !== null) {
+      span.status.message = row.status_message;
+    }
+    if (row.links && row.links !== "null") {
+      const links = JSON.parse(row.links);
+      if (links && links.length > 0) {
+        span.links = links;
+      }
+    }
+    if (row.resource && row.resource !== "null") {
+      const resource = JSON.parse(row.resource);
+      if (resource && Object.keys(resource).length > 0) {
+        span.resource = resource;
+      }
+    }
+    if (row.instrumentation_scope && row.instrumentation_scope !== "null") {
+      const scope = JSON.parse(row.instrumentation_scope);
+      if (scope) {
+        span.instrumentationScope = scope;
+      }
+    }
+    return span;
   }
   /**
-   * Add a history step
-   * @param key Step ID
-   * @param value Step data
-   * @param historyId Related history entry ID
-   * @param agentId Agent ID for filtering
+   * Get statistics about stored spans
    */
-  async addHistoryStep(key, value, historyId, agentId) {
-    await this.initialized;
+  async getStats() {
+    await this.ensureInitialized();
     try {
-      const tableName = `${this.options.tablePrefix}_agent_history_steps`;
-      const serializedValue = safeStringify2(value);
-      await this.client.execute({
-        sql: `INSERT OR REPLACE INTO ${tableName} (key, value, history_id, agent_id) VALUES (?, ?, ?, ?)`,
-        args: [key, serializedValue, historyId, agentId]
-      });
-      this.debug(`Set agent_history_steps:${key} for history ${historyId} and agent ${agentId}`);
+      const [spanCountResult, traceCountResult, timeRangeResult] = await Promise.all([
+        this.client.execute(`SELECT COUNT(*) as count FROM ${this.tablePrefix}_spans`),
+        this.client.execute(`SELECT COUNT(*) as count FROM ${this.tablePrefix}_traces`),
+        this.client.execute(`
+          SELECT 
+            MIN(start_time) as oldest,
+            MAX(start_time) as newest
+          FROM ${this.tablePrefix}_spans
+        `)
+      ]);
+      const stats = {
+        spanCount: spanCountResult.rows[0].count,
+        traceCount: traceCountResult.rows[0].count
+      };
+      if (timeRangeResult.rows[0].oldest) {
+        stats.oldestSpan = new Date(timeRangeResult.rows[0].oldest);
+      }
+      if (timeRangeResult.rows[0].newest) {
+        stats.newestSpan = new Date(timeRangeResult.rows[0].newest);
+      }
+      return stats;
     } catch (error) {
-      this.debug(`Error setting agent_history_steps:${key}`, error);
-      throw new Error("Failed to set value in agent_history_steps");
+      this.logger.error("Failed to get stats", { error });
+      throw error;
     }
   }
   /**
-   * 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
+   * Save a log record to the database
    */
-  async updateHistoryStep(key, value, historyId, agentId) {
-    return this.addHistoryStep(key, value, historyId, agentId);
-  }
-  /**
-   * 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
-   */
-  async addTimelineEvent(key, value, historyId, agentId) {
-    await this.initialized;
+  async saveLogRecord(logRecord) {
+    await this.ensureInitialized();
     try {
-      const tableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
-      const inputJSON = value.input ? safeStringify2(value.input) : null;
-      const outputJSON = value.output ? safeStringify2(value.output) : null;
-      const statusMessageJSON = value.statusMessage ? safeStringify2(value.statusMessage) : null;
-      const metadataJSON = value.metadata ? safeStringify2(value.metadata) : null;
-      const tagsJSON = value.tags ? safeStringify2(value.tags) : null;
+      let timestamp;
+      if (Array.isArray(logRecord.hrTime)) {
+        const timeMs = logRecord.hrTime[0] * 1e3 + logRecord.hrTime[1] / 1e6;
+        timestamp = new Date(timeMs).toISOString();
+      } else if (logRecord.timestamp) {
+        timestamp = typeof logRecord.timestamp === "string" ? logRecord.timestamp : new Date(logRecord.timestamp).toISOString();
+      } else {
+        timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      const spanContext = logRecord.spanContext || {};
+      const traceId = spanContext.traceId || null;
+      const spanId = spanContext.spanId || null;
+      const traceFlags = spanContext.traceFlags ?? null;
+      const severityNumber = logRecord.severityNumber ?? null;
+      const severityText = logRecord.severityText || null;
+      const body = typeof logRecord.body === "string" ? logRecord.body : safeStringify(logRecord.body);
+      const attributes = logRecord.attributes ? safeStringify(logRecord.attributes) : null;
+      const resource = logRecord.resource?.attributes ? safeStringify(logRecord.resource.attributes) : null;
+      const instrumentationScope = logRecord.instrumentationLibrary || logRecord.instrumentationScope ? safeStringify(logRecord.instrumentationLibrary || logRecord.instrumentationScope) : null;
       await this.client.execute({
-        sql: `INSERT OR REPLACE INTO ${tableName} 
-              (id, history_id, agent_id, event_type, event_name, 
-               start_time, end_time, status, status_message, level, 
-               version, parent_event_id, tags,
-               input, output, error, metadata) 
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        sql: `
+          INSERT INTO ${this.tablePrefix}_logs (
+            timestamp, trace_id, span_id, trace_flags,
+            severity_number, severity_text, body,
+            attributes, resource, instrumentation_scope
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
         args: [
-          key,
-          historyId,
-          agentId,
-          value.type,
-          value.name,
-          value.startTime,
-          value.endTime || null,
-          value.status || null,
-          statusMessageJSON || null,
-          value.level || "INFO",
-          value.version || null,
-          value.parentEventId || null,
-          tagsJSON,
-          inputJSON,
-          outputJSON,
-          statusMessageJSON,
-          metadataJSON
+          timestamp,
+          traceId,
+          spanId,
+          traceFlags,
+          severityNumber,
+          severityText,
+          body,
+          attributes,
+          resource,
+          instrumentationScope
         ]
       });
-      this.debug(`Added timeline event ${key} for history ${historyId}`);
+      this.debugLog("Log record saved successfully", {
+        timestamp,
+        traceId,
+        spanId,
+        severityNumber
+      });
     } catch (error) {
-      this.debug("Error adding timeline event:", error);
-      throw new Error("Failed to add timeline event");
+      this.logger.error("Failed to save log record", { error, logRecord });
+      throw error;
     }
   }
   /**
-   * Get a history entry by ID
-   * @param key Entry ID
-   * @returns The history entry or undefined if not found
+   * Get logs by trace ID
    */
-  async getHistoryEntry(key) {
-    await this.initialized;
+  async getLogsByTraceId(traceId) {
+    await this.ensureInitialized();
     try {
-      const tableName = `${this.options.tablePrefix}_agent_history`;
       const result = await this.client.execute({
-        sql: `SELECT id, agent_id, timestamp, status, input, output, usage, metadata, userId, conversationId 
-				FROM ${tableName} WHERE id = ?`,
-        args: [key]
-      });
-      if (result.rows.length === 0) {
-        this.debug(`History entry with ID ${key} not found`);
-        return void 0;
-      }
-      const row = result.rows[0];
-      const entry = {
-        id: row.id,
-        _agentId: row.agent_id,
-        // Keep _agentId for compatibility
-        timestamp: new Date(row.timestamp),
-        status: row.status,
-        input: row.input ? safeJsonParse(row.input) : null,
-        output: row.output ? safeJsonParse(row.output) : null,
-        usage: row.usage ? safeJsonParse(row.usage) : null,
-        metadata: row.metadata ? safeJsonParse(row.metadata) : null,
-        userId: row.userId,
-        conversationId: row.conversationId
-      };
-      this.debug(`Got history entry with ID ${key}`);
-      const stepsTableName = `${this.options.tablePrefix}_agent_history_steps`;
-      const stepsResult = await this.client.execute({
-        sql: `SELECT value FROM ${stepsTableName} WHERE history_id = ? AND agent_id = ?`,
-        args: [key, entry._agentId]
-      });
-      const steps = stepsResult.rows.map((row2) => {
-        const step = safeJsonParse(row2.value);
-        return {
-          type: step.type,
-          name: step.name,
-          content: step.content,
-          arguments: step.arguments
-        };
-      });
-      const timelineEventsTableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
-      const timelineEventsResult = await this.client.execute({
-        sql: `SELECT id, event_type, event_name, start_time, end_time, 
-					status, status_message, level, version, 
-					parent_event_id, tags, input, output, error, metadata 
-					FROM ${timelineEventsTableName} 
-					WHERE history_id = ? AND agent_id = ?`,
-        args: [key, entry._agentId]
-      });
-      const events = timelineEventsResult.rows.map((row2) => {
-        const input = row2.input ? safeJsonParse(row2.input) : void 0;
-        const output = row2.output ? safeJsonParse(row2.output) : void 0;
-        const error = row2.error ? safeJsonParse(row2.error) : void 0;
-        const statusMessage = row2.status_message ? safeJsonParse(row2.status_message) : void 0;
-        const metadata = row2.metadata ? safeJsonParse(row2.metadata) : void 0;
-        const tags = row2.tags ? safeJsonParse(row2.tags) : void 0;
-        return {
-          id: row2.id,
-          type: row2.event_type,
-          name: row2.event_name,
-          startTime: row2.start_time,
-          endTime: row2.end_time,
-          status: row2.status,
-          statusMessage,
-          level: row2.level,
-          version: row2.version,
-          parentEventId: row2.parent_event_id,
-          tags,
-          input,
-          output,
-          error: statusMessage ? statusMessage : error,
-          metadata
-        };
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          WHERE trace_id = ?
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
+        args: [traceId, this.maxSpansPerQuery]
       });
-      entry.steps = steps;
-      entry.events = events;
-      return entry;
+      return result.rows.map((row) => this.rowToLogRecord(row));
     } catch (error) {
-      this.debug(`Error getting history entry with ID ${key}`, error);
-      return void 0;
+      this.logger.error("Failed to get logs by trace ID", { error, traceId });
+      throw error;
     }
   }
   /**
-   * Get a history step by ID
-   * @param key Step ID
-   * @returns The history step or undefined if not found
+   * Get logs by span ID
    */
-  async getHistoryStep(key) {
-    await this.initialized;
-    try {
-      const tableName = `${this.options.tablePrefix}_agent_history_steps`;
-      const result = await this.client.execute({
-        sql: `SELECT value FROM ${tableName} WHERE key = ?`,
-        args: [key]
-      });
-      if (result.rows.length === 0) {
-        this.debug(`History step with ID ${key} not found`);
-        return void 0;
-      }
-      const value = safeJsonParse(result.rows[0].value);
-      this.debug(`Got history step with ID ${key}`);
-      return value;
-    } catch (error) {
-      this.debug(`Error getting history step with ID ${key}`, error);
-      return void 0;
-    }
-  }
-  async createConversation(conversation) {
-    await this.initialized;
-    await debugDelay();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const metadataString = safeStringify2(conversation.metadata);
-    const tableName = `${this.options.tablePrefix}_conversations`;
-    return await this.executeWithRetryStrategy(async () => {
-      await this.client.execute({
-        sql: `INSERT INTO ${tableName} (id, resource_id, user_id, title, metadata, created_at, updated_at)
-              VALUES (?, ?, ?, ?, ?, ?, ?)`,
-        args: [
-          conversation.id,
-          conversation.resourceId,
-          conversation.userId,
-          conversation.title,
-          metadataString,
-          now,
-          now
-        ]
-      });
-      return {
-        id: conversation.id,
-        resourceId: conversation.resourceId,
-        userId: conversation.userId,
-        title: conversation.title,
-        metadata: conversation.metadata,
-        createdAt: now,
-        updatedAt: now
-      };
-    }, `createConversation[${conversation.id}]`);
-  }
-  async getConversation(id) {
-    await this.initialized;
-    await debugDelay();
-    const tableName = `${this.options.tablePrefix}_conversations`;
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${tableName} WHERE id = ?`,
-        args: [id]
-      });
-      if (result.rows.length === 0) {
-        return null;
-      }
-      const row = result.rows[0];
-      return {
-        id: row.id,
-        resourceId: row.resource_id,
-        userId: row.user_id,
-        title: row.title,
-        metadata: row.metadata ? safeJsonParse(row.metadata) : {},
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    } catch (error) {
-      this.debug("Error getting conversation:", error);
-      throw new Error("Failed to get conversation from LibSQL database");
-    }
-  }
-  async getConversations(resourceId) {
-    await this.initialized;
-    await debugDelay();
-    const tableName = `${this.options.tablePrefix}_conversations`;
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${tableName} WHERE resource_id = ? ORDER BY updated_at DESC`,
-        args: [resourceId]
-      });
-      return result.rows.map((row) => ({
-        id: row.id,
-        resourceId: row.resource_id,
-        userId: row.user_id,
-        title: row.title,
-        metadata: safeJsonParse(row.metadata),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      }));
-    } catch (error) {
-      this.debug("Error getting conversations:", error);
-      throw new Error("Failed to get conversations from LibSQL database");
-    }
-  }
-  async getConversationsByUserId(userId, options = {}) {
-    await this.initialized;
-    await debugDelay();
-    const {
-      resourceId,
-      limit = 50,
-      offset = 0,
-      orderBy = "updated_at",
-      orderDirection = "DESC"
-    } = options;
-    const tableName = `${this.options.tablePrefix}_conversations`;
+  async getLogsBySpanId(spanId) {
+    await this.ensureInitialized();
     try {
-      let sql = `SELECT * FROM ${tableName} WHERE user_id = ?`;
-      const args = [userId];
-      if (resourceId) {
-        sql += " AND resource_id = ?";
-        args.push(resourceId);
-      }
-      sql += ` ORDER BY ${orderBy} ${orderDirection}`;
-      if (limit > 0) {
-        sql += " LIMIT ? OFFSET ?";
-        args.push(limit, offset);
-      }
       const result = await this.client.execute({
-        sql,
-        args
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          WHERE span_id = ?
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
+        args: [spanId, this.maxSpansPerQuery]
       });
-      return result.rows.map((row) => ({
-        id: row.id,
-        resourceId: row.resource_id,
-        userId: row.user_id,
-        title: row.title,
-        metadata: safeJsonParse(row.metadata),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      }));
+      return result.rows.map((row) => this.rowToLogRecord(row));
     } catch (error) {
-      this.debug("Error getting conversations by user ID:", error);
-      throw new Error("Failed to get conversations by user ID from LibSQL database");
+      this.logger.error("Failed to get logs by span ID", { error, spanId });
+      throw error;
     }
   }
   /**
-   * 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}
+   * Query logs with flexible filtering
    */
-  async queryConversations(options) {
-    await this.initialized;
-    await debugDelay();
-    const {
-      userId,
-      resourceId,
-      limit = 50,
-      offset = 0,
-      orderBy = "updated_at",
-      orderDirection = "DESC"
-    } = options;
-    const tableName = `${this.options.tablePrefix}_conversations`;
+  async queryLogs(filter) {
+    await this.ensureInitialized();
     try {
-      let sql = `SELECT * FROM ${tableName}`;
+      const whereClauses = [];
       const args = [];
-      const conditions = [];
-      if (userId) {
-        conditions.push("user_id = ?");
-        args.push(userId);
+      if (filter.traceId) {
+        whereClauses.push("trace_id = ?");
+        args.push(filter.traceId);
       }
-      if (resourceId) {
-        conditions.push("resource_id = ?");
-        args.push(resourceId);
+      if (filter.spanId) {
+        whereClauses.push("span_id = ?");
+        args.push(filter.spanId);
       }
-      if (conditions.length > 0) {
-        sql += ` WHERE ${conditions.join(" AND ")}`;
+      if (filter.severityNumber !== void 0) {
+        whereClauses.push("severity_number >= ?");
+        args.push(filter.severityNumber);
       }
-      sql += ` ORDER BY ${orderBy} ${orderDirection}`;
-      if (limit > 0) {
-        sql += " LIMIT ? OFFSET ?";
-        args.push(limit, offset);
+      if (filter.severityText) {
+        whereClauses.push("severity_text = ?");
+        args.push(filter.severityText);
+      }
+      if (filter.instrumentationScope) {
+        whereClauses.push("instrumentation_scope LIKE ?");
+        args.push(`%${filter.instrumentationScope}%`);
+      }
+      if (filter.startTimeMin !== void 0) {
+        const minTime = new Date(filter.startTimeMin).toISOString();
+        whereClauses.push("timestamp >= ?");
+        args.push(minTime);
       }
+      if (filter.startTimeMax !== void 0) {
+        const maxTime = new Date(filter.startTimeMax).toISOString();
+        whereClauses.push("timestamp <= ?");
+        args.push(maxTime);
+      }
+      if (filter.bodyContains) {
+        whereClauses.push("body LIKE ?");
+        args.push(`%${filter.bodyContains}%`);
+      }
+      const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+      const limit = filter.limit || this.maxSpansPerQuery;
+      args.push(limit);
       const result = await this.client.execute({
-        sql,
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          ${whereClause}
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
         args
       });
-      return result.rows.map((row) => ({
-        id: row.id,
-        resourceId: row.resource_id,
-        userId: row.user_id,
-        title: row.title,
-        metadata: safeJsonParse(row.metadata),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      }));
+      const logs = result.rows.map((row) => this.rowToLogRecord(row));
+      if (filter.attributeKey) {
+        const key = filter.attributeKey;
+        return logs.filter((log) => {
+          if (!log.attributes) return false;
+          if (filter.attributeValue !== void 0) {
+            return log.attributes[key] === filter.attributeValue;
+          }
+          return key in log.attributes;
+        });
+      }
+      return logs;
     } catch (error) {
-      this.debug("Error querying conversations:", error);
-      throw new Error("Failed to query conversations from LibSQL database");
+      this.logger.error("Failed to query logs", { error, filter });
+      throw error;
     }
   }
   /**
-   * 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}
+   * Delete old logs
    */
-  async getConversationMessages(conversationId, options = {}) {
-    await this.initialized;
-    await debugDelay();
-    const { limit = 100, offset = 0 } = options;
-    const tableName = `${this.options.tablePrefix}_messages`;
+  async deleteOldLogs(beforeTimestamp) {
+    await this.ensureInitialized();
     try {
-      let sql = `SELECT * FROM ${tableName} WHERE conversation_id = ? ORDER BY created_at ASC`;
-      const args = [conversationId];
-      if (limit > 0) {
-        sql += " LIMIT ? OFFSET ?";
-        args.push(limit, offset);
-      }
+      const beforeDate = new Date(beforeTimestamp).toISOString();
       const result = await this.client.execute({
-        sql,
-        args
-      });
-      return result.rows.map((row) => {
-        let content = row.content;
-        const parsedContent = safeJsonParse(content);
-        if (parsedContent !== null) {
-          content = parsedContent;
-        }
-        return {
-          id: row.message_id,
-          role: row.role,
-          content,
-          type: row.type,
-          createdAt: row.created_at
-        };
+        sql: `
+          DELETE FROM ${this.tablePrefix}_logs
+          WHERE timestamp < ?
+        `,
+        args: [beforeDate]
       });
+      const deletedCount = result.rowsAffected || 0;
+      this.debugLog("Old logs deleted", { deletedCount, beforeDate });
+      return deletedCount;
     } catch (error) {
-      this.debug("Error getting conversation messages:", error);
-      throw new Error("Failed to get conversation messages from LibSQL database");
+      this.logger.error("Failed to delete old logs", { error, beforeTimestamp });
+      throw error;
     }
   }
-  async updateConversation(id, updates) {
-    await this.initialized;
-    await debugDelay();
-    const tableName = `${this.options.tablePrefix}_conversations`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      const updatesList = [];
-      const args = [];
-      if (updates.resourceId !== void 0) {
-        updatesList.push("resource_id = ?");
-        args.push(updates.resourceId);
-      }
-      if (updates.userId !== void 0) {
-        updatesList.push("user_id = ?");
-        args.push(updates.userId);
+  /**
+   * Convert a database row to an ObservabilityLogRecord
+   */
+  rowToLogRecord(row) {
+    const log = {
+      timestamp: row.timestamp,
+      body: (() => {
+        try {
+          const bodyStr = row.body;
+          if (bodyStr.startsWith("{") || bodyStr.startsWith("[")) {
+            return JSON.parse(bodyStr);
+          }
+        } catch {
+        }
+        return row.body;
+      })()
+    };
+    if (row.trace_id !== null) {
+      log.traceId = row.trace_id;
+    }
+    if (row.span_id !== null) {
+      log.spanId = row.span_id;
+    }
+    if (row.trace_flags !== null) {
+      log.traceFlags = row.trace_flags;
+    }
+    if (row.severity_number !== null) {
+      log.severityNumber = row.severity_number;
+    }
+    if (row.severity_text !== null) {
+      log.severityText = row.severity_text;
+    }
+    if (row.attributes && row.attributes !== "null") {
+      try {
+        const attributes = JSON.parse(row.attributes);
+        if (attributes && Object.keys(attributes).length > 0) {
+          log.attributes = attributes;
+        }
+      } catch {
       }
-      if (updates.title !== void 0) {
-        updatesList.push("title = ?");
-        args.push(updates.title);
+    }
+    if (row.resource && row.resource !== "null") {
+      try {
+        const resource = JSON.parse(row.resource);
+        if (resource && Object.keys(resource).length > 0) {
+          log.resource = resource;
+        }
+      } catch {
       }
-      if (updates.metadata !== void 0) {
-        updatesList.push("metadata = ?");
-        args.push(safeStringify2(updates.metadata));
+    }
+    if (row.instrumentation_scope && row.instrumentation_scope !== "null") {
+      try {
+        const scope = JSON.parse(row.instrumentation_scope);
+        if (scope) {
+          log.instrumentationScope = scope;
+        }
+      } catch {
       }
-      updatesList.push("updated_at = ?");
-      args.push(now);
-      args.push(id);
-      await this.client.execute({
-        sql: `UPDATE ${tableName} SET ${updatesList.join(", ")} WHERE id = ?`,
-        args
-      });
-      const updated = await this.getConversation(id);
-      if (!updated) {
-        throw new Error("Conversation not found after update");
+    }
+    return log;
+  }
+  /**
+   * Close the database connection
+   */
+  async close() {
+    this.debugLog("LibSQL observability adapter closed");
+  }
+};
+
+// src/vector-adapter.ts
+import fs2 from "fs";
+import path2 from "path";
+import { createClient as createClient3 } from "@libsql/client";
+import {
+  cosineSimilarity
+} from "@voltagent/core";
+import { createPinoLogger as createPinoLogger3 } from "@voltagent/logger";
+var LibSQLVectorAdapter = class {
+  static {
+    __name(this, "LibSQLVectorAdapter");
+  }
+  client;
+  tablePrefix;
+  maxVectorDimensions;
+  cacheSize;
+  batchSize;
+  debug;
+  logger;
+  maxRetries;
+  retryDelayMs;
+  url;
+  initialized = false;
+  vectorCache;
+  dimensions = null;
+  constructor(options = {}) {
+    this.tablePrefix = options.tablePrefix ?? "voltagent";
+    this.maxVectorDimensions = options.maxVectorDimensions ?? 1536;
+    this.cacheSize = options.cacheSize ?? 100;
+    this.batchSize = options.batchSize ?? 100;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 100;
+    this.debug = options.debug ?? false;
+    this.logger = options.logger ?? createPinoLogger3({
+      name: "libsql-vector-adapter",
+      level: this.debug ? "debug" : "info"
+    });
+    const requestedUrl = options.url ?? "file:./.voltagent/memory.db";
+    if (requestedUrl === ":memory:" || requestedUrl === "file::memory:" || requestedUrl.startsWith("file::memory:")) {
+      this.url = ":memory:";
+    } else {
+      this.url = requestedUrl;
+    }
+    if (this.url.startsWith("file:") && !this.url.startsWith("file::memory:")) {
+      const dbPath = this.url.replace("file:", "");
+      const dbDir = path2.dirname(dbPath);
+      if (!fs2.existsSync(dbDir)) {
+        fs2.mkdirSync(dbDir, { recursive: true });
       }
-      return updated;
-    } catch (error) {
-      this.debug("Error updating conversation:", error);
-      throw new Error("Failed to update conversation in LibSQL database");
     }
+    this.client = createClient3({
+      url: this.url,
+      authToken: options.authToken
+    });
+    this.vectorCache = /* @__PURE__ */ new Map();
   }
-  async deleteConversation(id) {
-    await this.initialized;
-    await debugDelay();
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
-    const messagesTableName = `${this.options.tablePrefix}_messages`;
+  /**
+   * Initialize the database schema
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const tableName = `${this.tablePrefix}_vectors`;
     try {
-      await this.client.execute({
-        sql: `DELETE FROM ${messagesTableName} WHERE conversation_id = ?`,
-        args: [id]
-      });
-      await this.client.execute({
-        sql: `DELETE FROM ${conversationsTableName} WHERE id = ?`,
-        args: [id]
-      });
+      await this.client.executeMultiple(`
+        BEGIN;
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          id TEXT PRIMARY KEY,
+          vector BLOB NOT NULL,
+          dimensions INTEGER NOT NULL,
+          metadata TEXT,
+          content TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_created ON ${tableName}(created_at);
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_dimensions ON ${tableName}(dimensions);
+        COMMIT;
+      `);
+      this.initialized = true;
+      this.logger.debug("Vector adapter initialized");
     } catch (error) {
-      this.debug("Error deleting conversation:", error);
-      throw new Error("Failed to delete conversation from LibSQL database");
+      this.logger.error("Failed to initialize vector adapter", error);
+      throw error;
     }
   }
   /**
-   * 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
+   * Serialize a vector to binary format
    */
-  async getAllHistoryEntriesByAgent(agentId, page, limit) {
-    await this.initialized;
-    try {
-      const tableName = `${this.options.tablePrefix}_agent_history`;
-      const offset = page * limit;
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as total FROM ${tableName} WHERE agent_id = ?`,
-        args: [agentId]
-      });
-      const total = Number(countResult.rows[0].total);
-      const result = await this.client.execute({
-        sql: `SELECT id, agent_id, timestamp, status, input, output, usage, metadata, userId, conversationId 
-					FROM ${tableName} WHERE agent_id = ?
-					ORDER BY timestamp DESC
-					LIMIT ? OFFSET ?`,
-        args: [agentId, limit, offset]
-      });
-      const entries = result.rows.map((row) => ({
-        id: row.id,
-        _agentId: row.agent_id,
-        // Keep _agentId for compatibility
-        timestamp: new Date(row.timestamp),
-        status: row.status,
-        input: row.input ? safeJsonParse(row.input) : null,
-        output: row.output ? safeJsonParse(row.output) : null,
-        usage: row.usage ? safeJsonParse(row.usage) : null,
-        metadata: row.metadata ? safeJsonParse(row.metadata) : null,
-        userId: row.userId,
-        conversationId: row.conversationId
-      }));
-      this.debug(`Got all history entries for agent ${agentId} (${entries.length} items)`);
-      const completeEntries = await Promise.all(
-        entries.map(async (entry) => {
-          const stepsTableName = `${this.options.tablePrefix}_agent_history_steps`;
-          const stepsResult = await this.client.execute({
-            sql: `SELECT value FROM ${stepsTableName} WHERE history_id = ? AND agent_id = ?`,
-            args: [entry.id, agentId]
-          });
-          const steps = stepsResult.rows.map((row) => {
-            const step = safeJsonParse(row.value);
-            return {
-              type: step.type,
-              name: step.name,
-              content: step.content,
-              arguments: step.arguments
-            };
-          });
-          const timelineEventsTableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
-          const timelineEventsResult = await this.client.execute({
-            sql: `SELECT id, event_type, event_name, start_time, end_time, 
-							status, status_message, level, version, 
-							parent_event_id, tags, input, output, error, metadata 
-							FROM ${timelineEventsTableName} 
-							WHERE history_id = ? AND agent_id = ?`,
-            args: [entry.id, agentId]
-          });
-          const events = timelineEventsResult.rows.map((row) => {
-            const input = row.input ? safeJsonParse(row.input) : void 0;
-            const output = row.output ? safeJsonParse(row.output) : void 0;
-            const error = row.error ? safeJsonParse(row.error) : void 0;
-            const statusMessage = row.status_message ? safeJsonParse(row.status_message) : void 0;
-            const metadata = row.metadata ? safeJsonParse(row.metadata) : void 0;
-            const tags = row.tags ? safeJsonParse(row.tags) : void 0;
-            return {
-              id: row.id,
-              type: row.event_type,
-              name: row.event_name,
-              startTime: row.start_time,
-              endTime: row.end_time,
-              status: row.status,
-              statusMessage,
-              level: row.level,
-              version: row.version,
-              parentEventId: row.parent_event_id,
-              tags,
-              input,
-              output,
-              error: statusMessage ? statusMessage : error,
-              metadata
-            };
-          });
-          entry.steps = steps;
-          entry.events = events;
-          return entry;
-        })
-      );
-      return {
-        entries: completeEntries,
-        total
-      };
-    } catch (error) {
-      this.debug(`Error getting history entries for agent ${agentId}`, error);
-      return {
-        entries: [],
-        total: 0
-      };
+  serializeVector(vector) {
+    const buffer = Buffer.allocUnsafe(vector.length * 4);
+    for (let i = 0; i < vector.length; i++) {
+      buffer.writeFloatLE(vector[i], i * 4);
     }
+    return buffer;
   }
   /**
-   * 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
-   * );
+   * Deserialize a vector from binary format
    */
-  async migrateAgentHistoryData(options = {}) {
-    const {
-      createBackup = true,
-      restoreFromBackup = false,
-      deleteBackupAfterSuccess = false
-    } = options;
-    const oldTableName = `${this.options.tablePrefix}_agent_history`;
-    const oldTableBackup = `${oldTableName}_backup`;
-    const timelineEventsTableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
-    try {
-      this.debug("Starting agent history migration...");
-      const flagCheck = await this.checkMigrationFlag("agent_history_data_migration");
-      if (flagCheck.alreadyCompleted) {
-        return { success: true, migratedCount: 0 };
-      }
-      if (restoreFromBackup) {
-        this.debug("Starting restoration from backup...");
-        const backupCheck = await this.client.execute({
-          sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-          args: [oldTableBackup]
-        });
-        if (backupCheck.rows.length === 0) {
-          throw new Error("No backup found to restore");
-        }
-        await this.client.execute("BEGIN TRANSACTION;");
-        await this.client.execute(`DROP TABLE IF EXISTS ${oldTableName};`);
-        await this.client.execute(`ALTER TABLE ${oldTableBackup} RENAME TO ${oldTableName};`);
-        await this.client.execute("COMMIT;");
-        this.debug("Restoration from backup completed successfully");
-        return {
-          success: true,
-          backupCreated: false
-        };
-      }
-      const tableInfoQuery = await this.client.execute(`PRAGMA table_info(${oldTableName})`);
-      if (tableInfoQuery.rows.length === 0) {
-        this.debug(`${oldTableName} table not found, migration not needed`);
-        return {
-          success: true,
-          migratedCount: 0
-        };
-      }
-      const hasValueColumn = tableInfoQuery.rows.some((row) => row.name === "value");
-      if (!hasValueColumn) {
-        this.debug("Table is already in new format, migration not needed");
-        return {
-          success: true,
-          migratedCount: 0
-        };
-      }
-      if (createBackup) {
-        this.debug("Creating backup...");
-        const backupCheck = await this.client.execute({
-          sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-          args: [oldTableBackup]
-        });
-        if (backupCheck.rows.length > 0) {
-          await this.client.execute(`DROP TABLE IF EXISTS ${oldTableBackup};`);
+  deserializeVector(buffer) {
+    let bytes;
+    if (buffer instanceof Buffer) {
+      bytes = buffer;
+    } else if (buffer instanceof ArrayBuffer) {
+      bytes = Buffer.from(buffer);
+    } else {
+      bytes = Buffer.from(buffer);
+    }
+    const vector = [];
+    for (let i = 0; i < bytes.length; i += 4) {
+      vector.push(bytes.readFloatLE(i));
+    }
+    return vector;
+  }
+  /**
+   * Execute a database operation with retries
+   */
+  async executeWithRetry(operation, context) {
+    let lastError;
+    let delay = this.retryDelayMs;
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`Operation failed (attempt ${attempt}): ${context}`, error);
+        if (attempt < this.maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delay *= 2;
         }
-        await this.client.execute(
-          `CREATE TABLE ${oldTableBackup} AS SELECT * FROM ${oldTableName};`
-        );
-        this.debug("Backup created successfully");
       }
-      const oldFormatData = await this.client.execute({
-        sql: `SELECT key, value, agent_id FROM ${oldTableName}`
+    }
+    this.logger.error(`Operation failed after ${this.maxRetries} attempts: ${context}`, lastError);
+    throw lastError;
+  }
+  /**
+   * Store a vector with associated metadata
+   */
+  async store(id, vector, metadata) {
+    await this.initialize();
+    if (!Array.isArray(vector) || vector.length === 0) {
+      throw new Error("Vector must be a non-empty array");
+    }
+    if (vector.length > this.maxVectorDimensions) {
+      throw new Error(
+        `Vector dimensions (${vector.length}) exceed maximum (${this.maxVectorDimensions})`
+      );
+    }
+    if (this.dimensions === null) {
+      this.dimensions = vector.length;
+    } else if (vector.length !== this.dimensions) {
+      throw new Error(
+        `Vector dimension mismatch. Expected ${this.dimensions}, got ${vector.length}`
+      );
+    }
+    const tableName = `${this.tablePrefix}_vectors`;
+    const serializedVector = this.serializeVector(vector);
+    const metadataJson = metadata ? JSON.stringify(metadata) : null;
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `
+          INSERT OR REPLACE INTO ${tableName} 
+          (id, vector, dimensions, metadata, updated_at)
+          VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+        `,
+        args: [id, serializedVector, vector.length, metadataJson]
       });
-      if (oldFormatData.rows.length === 0) {
-        this.debug("No data found to migrate");
-        return {
-          success: true,
-          migratedCount: 0,
-          backupCreated: createBackup
-        };
-      }
-      const tempTableName = `${oldTableName}_temp`;
-      await this.client.execute(`
-        CREATE TABLE ${tempTableName} (
-          id TEXT PRIMARY KEY,
-          agent_id TEXT NOT NULL,
-          timestamp TEXT NOT NULL,
-          status TEXT,
-          input TEXT,
-          output TEXT,
-          usage TEXT,
-          metadata TEXT
-        )
-      `);
-      await this.client.execute("BEGIN TRANSACTION;");
-      let migratedCount = 0;
-      const migratedIds = /* @__PURE__ */ new Set();
-      for (const row of oldFormatData.rows) {
-        const key = row.key;
-        const agentId = row.agent_id;
-        const valueStr = row.value;
-        try {
-          const valueObj = safeJsonParse(valueStr);
-          const id = valueObj.id || key;
-          if (migratedIds.has(id)) {
-            continue;
+    }, `store vector ${id}`);
+    if (this.vectorCache.size >= this.cacheSize) {
+      const firstKey = this.vectorCache.keys().next().value;
+      if (firstKey) this.vectorCache.delete(firstKey);
+    }
+    this.vectorCache.set(id, { id, vector, metadata });
+    this.logger.debug(`Vector stored: ${id} (${vector.length} dimensions)`);
+  }
+  /**
+   * Store multiple vectors in batch
+   */
+  async storeBatch(items) {
+    await this.initialize();
+    if (items.length === 0) return;
+    const tableName = `${this.tablePrefix}_vectors`;
+    for (let i = 0; i < items.length; i += this.batchSize) {
+      const batch = items.slice(i, i + this.batchSize);
+      await this.executeWithRetry(async () => {
+        const stmts = [];
+        for (const item of batch) {
+          if (!Array.isArray(item.vector) || item.vector.length === 0) {
+            throw new Error("Vector must be a non-empty array");
           }
-          migratedIds.add(id);
-          migratedCount++;
-          const inputJSON = valueObj.input ? safeStringify2(valueObj.input) : null;
-          const outputJSON = valueObj.output ? safeStringify2(valueObj.output) : null;
-          const usageJSON = valueObj.usage ? safeStringify2(valueObj.usage) : null;
-          await this.client.execute({
-            sql: `INSERT INTO ${tempTableName} 
-                    (id, agent_id, timestamp, status, input, output, usage, metadata) 
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-            args: [
-              id,
-              valueObj._agentId || agentId,
-              valueObj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-              valueObj.status || null,
-              inputJSON,
-              outputJSON,
-              usageJSON,
-              null
-            ]
-          });
-          let input = "";
-          if (Array.isArray(valueObj.events)) {
-            for (const event of valueObj.events) {
-              try {
-                if (event.affectedNodeId?.startsWith("message_")) {
-                  input = event.data.input;
-                  continue;
-                }
-                const eventId = event.id || this.generateId();
-                const eventType = event.type || "unknown";
-                let eventName = event.name || "unknown";
-                const startTime = event.timestamp || event.startTime || (/* @__PURE__ */ new Date()).toISOString();
-                const endTime = event.updatedAt || event.endTime || startTime;
-                let status = event.status || event.data?.status || null;
-                let inputData = null;
-                if (event.input) {
-                  inputData = safeStringify2({ input: event.input });
-                } else if (event.data?.input) {
-                  inputData = safeStringify2({ input: event.data.input });
-                } else if (input) {
-                  inputData = safeStringify2({ input });
-                }
-                input = "";
-                let metadata = null;
-                if (event.metadata) {
-                  metadata = safeStringify2(event.metadata);
-                } else if (event.data) {
-                  metadata = safeStringify2({
-                    id: event.affectedNodeId?.split("_").pop(),
-                    agentId: event.data?.metadata?.sourceAgentId,
-                    ...event.data
-                  });
-                }
-                if (eventType === "agent") {
-                  if (eventName === "start") {
-                    eventName = "agent:start";
-                    status = "running";
-                  } else if (eventName === "finished") {
-                    if (event.data.status === "error") {
-                      eventName = "agent:error";
-                    } else {
-                      eventName = "agent:success";
-                    }
-                  }
-                  await this.client.execute({
-                    sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                          (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                          status, status_message, level, version, parent_event_id, 
-                          tags, input, output, error, metadata)
-                          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                    args: [
-                      eventId,
-                      id,
-                      valueObj._agentId || agentId,
-                      eventType,
-                      eventName,
-                      startTime,
-                      endTime,
-                      // @ts-ignore
-                      status,
-                      eventName === "agent:error" ? event.data.error.message : null,
-                      event.level || "INFO",
-                      event.version || null,
-                      event.parentEventId || null,
-                      null,
-                      // tags
-                      inputData,
-                      event.data.output ? safeStringify2(event.data.output) : null,
-                      eventName === "agent:error" ? safeStringify2(event.data.error) : null,
-                      metadata
-                    ]
-                  });
-                } else if (eventType === "memory") {
-                  if (eventName === "memory:saveMessage") {
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                            (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                            status, status_message, level, version, parent_event_id, 
-                            tags, input, output, error, metadata)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        eventId,
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "memory:write_start",
-                        startTime,
-                        null,
-                        // no endTime
-                        "running",
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        event.parentEventId || null,
-                        null,
-                        // tags
-                        inputData,
-                        null,
-                        // no output
-                        null,
-                        // no error
-                        safeStringify2({
-                          id: "memory",
-                          agentId: event.affectedNodeId?.split("_").pop()
-                        })
-                      ]
-                    });
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                            (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                            status, status_message, level, version, parent_event_id, 
-                            tags, input, output, error, metadata)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        this.generateId(),
-                        // New ID
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "memory:write_success",
-                        endTime,
-                        // End time
-                        endTime,
-                        "completed",
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        eventId,
-                        // Parent event ID
-                        null,
-                        // tags
-                        inputData,
-                        event.data.output ? safeStringify2(event.data.output) : null,
-                        event.error ? safeStringify2(event.error) : null,
-                        safeStringify2({
-                          id: "memory",
-                          agentId: event.affectedNodeId?.split("_").pop()
-                        })
-                      ]
-                    });
-                  } else if (eventName === "memory:getMessages") {
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                            (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                            status, status_message, level, version, parent_event_id, 
-                            tags, input, output, error, metadata)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        eventId,
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "memory:read_start",
-                        startTime,
-                        null,
-                        // no endTime
-                        "running",
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        event.parentEventId || null,
-                        null,
-                        // tags
-                        inputData,
-                        null,
-                        // no output
-                        null,
-                        // no error
-                        safeStringify2({
-                          id: "memory",
-                          agentId: event.affectedNodeId?.split("_").pop()
-                        })
-                      ]
-                    });
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                            (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                            status, status_message, level, version, parent_event_id, 
-                            tags, input, output, error, metadata)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        this.generateId(),
-                        // New ID
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "memory:read_success",
-                        endTime,
-                        // End time
-                        endTime,
-                        status,
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        eventId,
-                        // Parent event ID
-                        null,
-                        // tags
-                        inputData,
-                        event.data.output ? safeStringify2(event.data.output) : null,
-                        event.error ? safeStringify2(event.error) : null,
-                        safeStringify2({
-                          id: "memory",
-                          agentId: event.affectedNodeId?.split("_").pop()
-                        })
-                      ]
-                    });
-                  } else {
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                            (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                            status, status_message, level, version, parent_event_id, 
-                            tags, input, output, error, metadata)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        eventId,
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        eventName,
-                        startTime,
-                        endTime,
-                        status,
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        event.parentEventId || null,
-                        null,
-                        // tags
-                        inputData,
-                        event.output ? safeStringify2(event.output) : null,
-                        event.error ? safeStringify2(event.error) : null,
-                        metadata
-                      ]
-                    });
-                  }
-                } else if (eventType === "tool") {
-                  if (eventName === "tool_working") {
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-								(id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-								status, status_message, level, version, parent_event_id, 
-								tags, input, output, error, metadata)
-								VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        eventId,
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "tool:start",
-                        startTime,
-                        null,
-                        // no endTime
-                        "running",
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        event.parentEventId || null,
-                        null,
-                        // tags
-                        inputData,
-                        null,
-                        // no output
-                        null,
-                        // no error
-                        safeStringify2({
-                          id: event.affectedNodeId?.split("_").pop(),
-                          agentId: event.data?.metadata?.sourceAgentId,
-                          displayName: event.data.metadata.toolName
-                        })
-                      ]
-                    });
-                    await this.client.execute({
-                      sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-								(id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-								status, status_message, level, version, parent_event_id, 
-								tags, input, output, error, metadata)
-								VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                      args: [
-                        this.generateId(),
-                        // New ID
-                        id,
-                        valueObj._agentId || agentId,
-                        eventType,
-                        "tool:success",
-                        endTime,
-                        // End time
-                        endTime,
-                        "completed",
-                        event.statusMessage || null,
-                        event.level || "INFO",
-                        event.version || null,
-                        eventId,
-                        // Parent event ID
-                        null,
-                        // tags
-                        inputData,
-                        event.data.output ? safeStringify2(event.data.output) : null,
-                        event.error ? safeStringify2(event.error) : null,
-                        safeStringify2({
-                          id: event.affectedNodeId?.split("_").pop(),
-                          agentId: event.data?.metadata?.sourceAgentId,
-                          displayName: event.data.metadata.toolName
-                        })
-                      ]
-                    });
-                  }
-                } else {
-                  await this.client.execute({
-                    sql: `INSERT OR REPLACE INTO ${timelineEventsTableName}
-                          (id, history_id, agent_id, event_type, event_name, start_time, end_time, 
-                          status, status_message, level, version, parent_event_id, 
-                          tags, input, output, error, metadata)
-                          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                    args: [
-                      eventId,
-                      id,
-                      valueObj._agentId || agentId,
-                      eventType,
-                      eventName,
-                      startTime,
-                      endTime,
-                      status,
-                      event.statusMessage || null,
-                      event.level || "INFO",
-                      event.version || null,
-                      event.parentEventId || null,
-                      null,
-                      // tags
-                      inputData,
-                      event.output ? safeStringify2(event.output) : null,
-                      event.error ? safeStringify2(event.error) : null,
-                      safeStringify2({
-                        id: eventType === "retriever" ? "retriever" : event.type,
-                        agentId: event.affectedNodeId?.split("_").pop()
-                      })
-                    ]
-                  });
-                }
-              } catch (error) {
-                this.debug("Error processing event:", error);
-              }
-            }
+          if (this.dimensions === null) {
+            this.dimensions = item.vector.length;
+          } else if (item.vector.length !== this.dimensions) {
+            throw new Error(
+              `Vector dimension mismatch. Expected ${this.dimensions}, got ${item.vector.length}`
+            );
           }
-        } catch (error) {
-          this.debug(`Error processing record with ID ${key}:`, error);
+          const serializedVector = this.serializeVector(item.vector);
+          const metadataJson = item.metadata ? JSON.stringify(item.metadata) : null;
+          const content = item.content ?? null;
+          stmts.push({
+            sql: `INSERT OR REPLACE INTO ${tableName} (id, vector, dimensions, metadata, content, updated_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+            args: [item.id, serializedVector, item.vector.length, metadataJson, content]
+          });
         }
-      }
-      await this.client.execute(`DROP TABLE ${oldTableName};`);
-      await this.client.execute(`ALTER TABLE ${tempTableName} RENAME TO ${oldTableName};`);
-      await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${oldTableName}_agent_id 
-        ON ${oldTableName}(agent_id)
-      `);
-      await this.client.execute("COMMIT;");
-      this.debug(`Total ${migratedCount} records successfully migrated`);
-      if (createBackup && deleteBackupAfterSuccess) {
-        await this.client.execute(`DROP TABLE IF EXISTS ${oldTableBackup};`);
-        this.debug("Unnecessary backup deleted");
-      }
-      await this.setMigrationFlag("agent_history_data_migration", migratedCount);
-      return {
-        success: true,
-        migratedCount,
-        backupCreated: createBackup && !deleteBackupAfterSuccess
-      };
-    } catch (error) {
-      await this.client.execute("ROLLBACK;");
-      this.debug("Error occurred while migrating agent history data:", error);
-      return {
-        success: false,
-        error: error instanceof Error ? error : new Error(String(error)),
-        backupCreated: options.createBackup
-      };
+        await this.client.batch(stmts, "write");
+      }, `storeBatch ${batch.length} vectors`);
+      this.logger.debug(`Batch of ${batch.length} vectors stored`);
     }
   }
   /**
-   * 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
+   * Search for similar vectors using cosine similarity
    */
-  async migrateConversationSchema(options = {}) {
-    const {
-      createBackup = true,
-      restoreFromBackup = false,
-      deleteBackupAfterSuccess = false
-    } = options;
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
-    const messagesTableName = `${this.options.tablePrefix}_messages`;
-    const conversationsBackupName = `${conversationsTableName}_backup`;
-    const messagesBackupName = `${messagesTableName}_backup`;
-    try {
-      this.debug("Starting conversation schema migration...");
-      const flagCheck = await this.checkMigrationFlag("conversation_schema_migration");
-      if (flagCheck.alreadyCompleted) {
-        return { success: true, migratedCount: 0 };
-      }
-      if (restoreFromBackup) {
-        this.debug("Starting restoration from backup...");
-        const convBackupCheck = await this.client.execute({
-          sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-          args: [conversationsBackupName]
-        });
-        const msgBackupCheck = await this.client.execute({
-          sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-          args: [messagesBackupName]
-        });
-        if (convBackupCheck.rows.length === 0 || msgBackupCheck.rows.length === 0) {
-          throw new Error("No backup found to restore");
-        }
-        await this.client.execute("BEGIN TRANSACTION;");
-        await this.client.execute(`DROP TABLE IF EXISTS ${conversationsTableName};`);
-        await this.client.execute(`DROP TABLE IF EXISTS ${messagesTableName};`);
-        await this.client.execute(
-          `ALTER TABLE ${conversationsBackupName} RENAME TO ${conversationsTableName};`
-        );
-        await this.client.execute(
-          `ALTER TABLE ${messagesBackupName} RENAME TO ${messagesTableName};`
-        );
-        await this.client.execute("COMMIT;");
-        this.debug("Restoration from backup completed successfully");
-        return { success: true, backupCreated: false };
-      }
-      const convTableInfo = await this.client.execute(
-        `PRAGMA table_info(${conversationsTableName})`
+  async search(queryVector, options) {
+    await this.initialize();
+    const { limit = 10, threshold = 0, filter } = options || {};
+    if (this.dimensions !== null && queryVector.length !== this.dimensions) {
+      throw new Error(
+        `Query vector dimension mismatch. Expected ${this.dimensions}, got ${queryVector.length}`
       );
-      const msgTableInfo = await this.client.execute(`PRAGMA table_info(${messagesTableName})`);
-      const hasUserIdInConversations = convTableInfo.rows.some((row) => row.name === "user_id");
-      const hasUserIdInMessages = msgTableInfo.rows.some((row) => row.name === "user_id");
-      if (hasUserIdInConversations && !hasUserIdInMessages) {
-        this.debug("Tables are already in new format, migration not needed");
-        return { success: true, migratedCount: 0 };
-      }
-      if (convTableInfo.rows.length === 0 && msgTableInfo.rows.length === 0) {
-        this.debug("Tables don't exist, migration not needed");
-        return { success: true, migratedCount: 0 };
-      }
-      if (createBackup) {
-        this.debug("Creating backups...");
-        await this.client.execute(`DROP TABLE IF EXISTS ${conversationsBackupName};`);
-        await this.client.execute(`DROP TABLE IF EXISTS ${messagesBackupName};`);
-        if (convTableInfo.rows.length > 0) {
-          await this.client.execute(
-            `CREATE TABLE ${conversationsBackupName} AS SELECT * FROM ${conversationsTableName};`
-          );
-        }
-        if (msgTableInfo.rows.length > 0) {
-          await this.client.execute(
-            `CREATE TABLE ${messagesBackupName} AS SELECT * FROM ${messagesTableName};`
-          );
-        }
-        this.debug("Backups created successfully");
-      }
-      let conversationData = [];
-      let messageData = [];
-      if (convTableInfo.rows.length > 0) {
-        const convResult = await this.client.execute(`SELECT * FROM ${conversationsTableName}`);
-        conversationData = convResult.rows;
-      }
-      if (msgTableInfo.rows.length > 0) {
-        const msgResult = await this.client.execute(`SELECT * FROM ${messagesTableName}`);
-        messageData = msgResult.rows;
+    }
+    const tableName = `${this.tablePrefix}_vectors`;
+    let query = `SELECT id, vector, dimensions, metadata, content FROM ${tableName}`;
+    const args = [];
+    if (this.dimensions !== null) {
+      query += " WHERE dimensions = ?";
+      args.push(this.dimensions);
+    }
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute({ sql: query, args }),
+      "search vectors"
+    );
+    const searchResults = [];
+    for (const row of result.rows) {
+      const id = row.id;
+      const vectorBlob = row.vector;
+      const metadataJson = row.metadata;
+      const content = row.content ?? void 0;
+      const metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+      if (filter && !this.matchesFilter(metadata, filter)) {
+        continue;
       }
-      await this.client.execute("BEGIN TRANSACTION;");
-      const tempConversationsTable = `${conversationsTableName}_temp`;
-      const tempMessagesTable = `${messagesTableName}_temp`;
-      await this.client.execute(`
-        CREATE TABLE ${tempConversationsTable} (
-          id TEXT PRIMARY KEY,
-          resource_id TEXT NOT NULL,
-          user_id TEXT NOT NULL,
-          title TEXT NOT NULL,
-          metadata TEXT NOT NULL,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      `);
-      await this.client.execute(`
-        CREATE TABLE ${tempMessagesTable} (
-          conversation_id TEXT NOT NULL,
-          message_id TEXT NOT NULL,
-          role TEXT NOT NULL,
-          content TEXT NOT NULL,
-          type TEXT NOT NULL,
-          created_at TEXT NOT NULL,
-          PRIMARY KEY (conversation_id, message_id)
-        )
-      `);
-      let migratedCount = 0;
-      const createdConversations = /* @__PURE__ */ new Set();
-      for (const row of messageData) {
-        const conversationId = row.conversation_id;
-        let userId = "default";
-        if (hasUserIdInMessages && row.user_id) {
-          userId = row.user_id;
-        }
-        if (!createdConversations.has(conversationId)) {
-          const existingConversation = conversationData.find((conv) => conv.id === conversationId);
-          if (existingConversation) {
-            let convUserId = userId;
-            if (hasUserIdInConversations && existingConversation.user_id) {
-              convUserId = existingConversation.user_id;
-            }
-            await this.client.execute({
-              sql: `INSERT INTO ${tempConversationsTable} 
-                    (id, resource_id, user_id, title, metadata, created_at, updated_at) 
-                    VALUES (?, ?, ?, ?, ?, ?, ?)`,
-              args: [
-                existingConversation.id,
-                existingConversation.resource_id,
-                convUserId,
-                existingConversation.title,
-                existingConversation.metadata,
-                existingConversation.created_at,
-                existingConversation.updated_at
-              ]
-            });
-          } else {
-            const now = (/* @__PURE__ */ new Date()).toISOString();
-            await this.client.execute({
-              sql: `INSERT INTO ${tempConversationsTable} 
-                    (id, resource_id, user_id, title, metadata, created_at, updated_at) 
-                    VALUES (?, ?, ?, ?, ?, ?, ?)`,
-              args: [
-                conversationId,
-                "default",
-                // Default resource_id for auto-created conversations
-                userId,
-                "Migrated Conversation",
-                // Default title
-                safeStringify2({}),
-                // Empty metadata
-                now,
-                now
-              ]
-            });
-          }
-          createdConversations.add(conversationId);
-          migratedCount++;
-        }
-        await this.client.execute({
-          sql: `INSERT INTO ${tempMessagesTable} 
-                (conversation_id, message_id, role, content, type, created_at) 
-                VALUES (?, ?, ?, ?, ?, ?)`,
-          args: [
-            row.conversation_id,
-            row.message_id,
-            row.role,
-            row.content,
-            row.type,
-            row.created_at
-          ]
+      const vector = this.deserializeVector(vectorBlob);
+      const similarity = cosineSimilarity(queryVector, vector);
+      const score = (similarity + 1) / 2;
+      if (score >= threshold) {
+        searchResults.push({
+          id,
+          vector,
+          metadata,
+          content,
+          score,
+          distance: 1 - similarity
+          // Convert to distance metric
         });
       }
-      for (const row of conversationData) {
-        const conversationId = row.id;
-        if (!createdConversations.has(conversationId)) {
-          let userId = "default";
-          if (hasUserIdInConversations && row.user_id) {
-            userId = row.user_id;
-          }
-          await this.client.execute({
-            sql: `INSERT INTO ${tempConversationsTable} 
-                  (id, resource_id, user_id, title, metadata, created_at, updated_at) 
-                  VALUES (?, ?, ?, ?, ?, ?, ?)`,
-            args: [
-              row.id,
-              row.resource_id,
-              userId,
-              row.title,
-              row.metadata,
-              row.created_at,
-              row.updated_at
-            ]
-          });
-          migratedCount++;
-        }
-      }
-      await this.client.execute(`DROP TABLE IF EXISTS ${conversationsTableName};`);
-      await this.client.execute(`DROP TABLE IF EXISTS ${messagesTableName};`);
-      await this.client.execute(
-        `ALTER TABLE ${tempConversationsTable} RENAME TO ${conversationsTableName};`
-      );
-      await this.client.execute(`ALTER TABLE ${tempMessagesTable} RENAME TO ${messagesTableName};`);
-      await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${messagesTableName}_lookup
-        ON ${messagesTableName}(conversation_id, created_at)
-      `);
-      await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${conversationsTableName}_resource
-        ON ${conversationsTableName}(resource_id)
-      `);
-      await this.client.execute(`
-        CREATE INDEX IF NOT EXISTS idx_${conversationsTableName}_user
-        ON ${conversationsTableName}(user_id)
-      `);
-      await this.client.execute("COMMIT;");
-      if (deleteBackupAfterSuccess) {
-        await this.client.execute(`DROP TABLE IF EXISTS ${conversationsBackupName};`);
-        await this.client.execute(`DROP TABLE IF EXISTS ${messagesBackupName};`);
-      }
-      await this.setMigrationFlag("conversation_schema_migration", migratedCount);
-      this.debug(
-        `Conversation schema migration completed successfully. Migrated ${migratedCount} conversations.`
-      );
-      return {
-        success: true,
-        migratedCount,
-        backupCreated: createBackup
-      };
-    } catch (error) {
-      this.debug("Error during conversation schema migration:", error);
-      try {
-        await this.client.execute("ROLLBACK;");
-      } catch (rollbackError) {
-        this.debug("Error rolling back transaction:", rollbackError);
+    }
+    searchResults.sort((a, b) => b.score - a.score);
+    return searchResults.slice(0, limit);
+  }
+  /**
+   * Check if metadata matches the filter criteria
+   */
+  matchesFilter(metadata, filter) {
+    if (!metadata) {
+      return false;
+    }
+    for (const [key, value] of Object.entries(filter)) {
+      if (metadata[key] !== value) {
+        return false;
       }
-      return {
-        success: false,
-        error,
-        backupCreated: createBackup
-      };
     }
+    return true;
   }
   /**
-   * Get conversations for a user with a fluent query builder interface
-   * @param userId User ID to filter by
-   * @returns Query builder object
+   * Delete a vector by ID
    */
-  getUserConversations(userId) {
-    return {
-      /**
-       * Limit the number of results
-       * @param count Number of conversations to return
-       * @returns Query builder
-       */
-      limit: /* @__PURE__ */ __name((count) => ({
-        /**
-         * Order results by a specific field
-         * @param field Field to order by
-         * @param direction Sort direction
-         * @returns Query builder
-         */
-        orderBy: /* @__PURE__ */ __name((field = "updated_at", direction = "DESC") => ({
-          /**
-           * Execute the query and return results
-           * @returns Promise of conversations
-           */
-          execute: /* @__PURE__ */ __name(() => this.getConversationsByUserId(userId, {
-            limit: count,
-            orderBy: field,
-            orderDirection: direction
-          }), "execute")
-        }), "orderBy"),
-        /**
-         * Execute the query with default ordering
-         * @returns Promise of conversations
-         */
-        execute: /* @__PURE__ */ __name(() => this.getConversationsByUserId(userId, { limit: count }), "execute")
-      }), "limit"),
-      /**
-       * Order results by a specific field
-       * @param field Field to order by
-       * @param direction Sort direction
-       * @returns Query builder
-       */
-      orderBy: /* @__PURE__ */ __name((field = "updated_at", direction = "DESC") => ({
-        /**
-         * Limit the number of results
-         * @param count Number of conversations to return
-         * @returns Query builder
-         */
-        limit: /* @__PURE__ */ __name((count) => ({
-          /**
-           * Execute the query and return results
-           * @returns Promise of conversations
-           */
-          execute: /* @__PURE__ */ __name(() => this.getConversationsByUserId(userId, {
-            limit: count,
-            orderBy: field,
-            orderDirection: direction
-          }), "execute")
-        }), "limit"),
-        /**
-         * Execute the query without limit
-         * @returns Promise of conversations
-         */
-        execute: /* @__PURE__ */ __name(() => this.getConversationsByUserId(userId, {
-          orderBy: field,
-          orderDirection: direction
-        }), "execute")
-      }), "orderBy"),
-      /**
-       * Execute the query with default options
-       * @returns Promise of conversations
-       */
-      execute: /* @__PURE__ */ __name(() => this.getConversationsByUserId(userId), "execute")
-    };
+  async delete(id) {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `DELETE FROM ${tableName} WHERE id = ?`,
+        args: [id]
+      });
+    }, `delete vector ${id}`);
+    this.vectorCache.delete(id);
+    this.logger.debug(`Vector deleted: ${id}`);
   }
   /**
-   * 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
+   * Delete multiple vectors by IDs
    */
-  async getUserConversation(conversationId, userId) {
-    const conversation = await this.getConversation(conversationId);
-    if (!conversation || conversation.userId !== userId) {
-      return null;
+  async deleteBatch(ids) {
+    await this.initialize();
+    if (ids.length === 0) return;
+    const tableName = `${this.tablePrefix}_vectors`;
+    for (let i = 0; i < ids.length; i += this.batchSize) {
+      const batch = ids.slice(i, i + this.batchSize);
+      const placeholders = batch.map(() => "?").join(",");
+      await this.executeWithRetry(async () => {
+        await this.client.execute({
+          sql: `DELETE FROM ${tableName} WHERE id IN (${placeholders})`,
+          args: batch
+        });
+      }, `deleteBatch ${batch.length} vectors`);
+      for (const id of batch) {
+        this.vectorCache.delete(id);
+      }
+      this.logger.debug(`Batch of ${batch.length} vectors deleted`);
     }
-    return conversation;
   }
   /**
-   * 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
+   * Clear all vectors
    */
-  async getPaginatedUserConversations(userId, page = 1, pageSize = 10) {
-    const offset = (page - 1) * pageSize;
-    const conversations = await this.getConversationsByUserId(userId, {
-      limit: pageSize + 1,
-      offset,
-      orderBy: "updated_at",
-      orderDirection: "DESC"
-    });
-    const hasMore = conversations.length > pageSize;
-    const results = hasMore ? conversations.slice(0, pageSize) : conversations;
-    return {
-      conversations: results,
-      page,
-      pageSize,
-      hasMore
-    };
+  async clear() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    await this.executeWithRetry(async () => {
+      await this.client.execute(`DELETE FROM ${tableName}`);
+    }, "clear all vectors");
+    this.vectorCache.clear();
+    this.dimensions = null;
+    this.logger.debug("All vectors cleared");
   }
   /**
-   * 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
+   * Get total count of stored vectors
    */
-  async checkMigrationFlag(migrationType) {
-    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
-    const migrationFlagTable = `${conversationsTableName}_migration_flags`;
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${migrationFlagTable} WHERE migration_type = ?`,
-        args: [migrationType]
-      });
-      if (result.rows.length > 0) {
-        const migrationFlag = result.rows[0];
-        this.debug(`${migrationType} migration already completed`);
-        this.debug(`Migration completed on: ${migrationFlag.completed_at}`);
-        this.debug(`Migrated ${migrationFlag.migrated_count || 0} records previously`);
+  async count() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute(`SELECT COUNT(*) as count FROM ${tableName}`),
+      "count vectors"
+    );
+    const raw = result.rows[0]?.count;
+    if (typeof raw === "bigint") return Number(raw);
+    if (typeof raw === "string") return Number.parseInt(raw, 10) || 0;
+    return raw ?? 0;
+  }
+  /**
+   * Get a specific vector by ID
+   */
+  async get(id) {
+    await this.initialize();
+    if (this.vectorCache.has(id)) {
+      const cached = this.vectorCache.get(id);
+      if (cached) {
         return {
-          alreadyCompleted: true,
-          migrationCount: migrationFlag.migrated_count,
-          completedAt: migrationFlag.completed_at
+          ...cached,
+          vector: [...cached.vector],
+          // Return a copy
+          metadata: cached.metadata ? { ...cached.metadata } : void 0
         };
       }
-      this.debug("Migration flags table found, but no migration flag exists yet");
-      return { alreadyCompleted: false };
-    } catch (flagError) {
-      this.debug("Migration flag table not found, creating it...");
-      this.debug("Original error:", flagError);
-      try {
-        await this.client.execute(`
-          CREATE TABLE IF NOT EXISTS ${migrationFlagTable} (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            migration_type TEXT NOT NULL UNIQUE,
-            completed_at TEXT NOT NULL DEFAULT (datetime('now')),
-            migrated_count INTEGER DEFAULT 0,
-            metadata TEXT DEFAULT '{}'
-          )
-        `);
-        this.debug("Migration flags table created successfully");
-      } catch (createError) {
-        this.debug("Failed to create migration flags table:", createError);
-      }
-      return { alreadyCompleted: false };
     }
-  }
-  /**
-   * Set migration flag after successful completion
-   * @param migrationType Type of migration completed
-   * @param migratedCount Number of records migrated
-   */
-  async setMigrationFlag(migrationType, migratedCount) {
-    try {
-      const conversationsTableName = `${this.options.tablePrefix}_conversations`;
-      const migrationFlagTable = `${conversationsTableName}_migration_flags`;
-      await this.client.execute({
-        sql: `INSERT OR REPLACE INTO ${migrationFlagTable} 
-              (migration_type, completed_at, migrated_count) 
-              VALUES (?, datetime('now'), ?)`,
-        args: [migrationType, migratedCount]
-      });
-      this.debug("Migration flag set successfully");
-    } catch (flagSetError) {
-      this.debug("Could not set migration flag (non-critical):", flagSetError);
+    const tableName = `${this.tablePrefix}_vectors`;
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute({
+        sql: `SELECT id, vector, metadata, content FROM ${tableName} WHERE id = ?`,
+        args: [id]
+      }),
+      `get vector ${id}`
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    const vectorBlob = row.vector;
+    const metadataJson = row.metadata;
+    const content = row.content;
+    const vector = this.deserializeVector(vectorBlob);
+    const metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+    const item = {
+      id,
+      vector,
+      metadata,
+      content: content ?? void 0
+    };
+    if (this.vectorCache.size >= this.cacheSize) {
+      const firstKey = this.vectorCache.keys().next().value;
+      if (firstKey) this.vectorCache.delete(firstKey);
     }
+    this.vectorCache.set(id, item);
+    return item;
   }
   /**
-   * Migrate agent history schema to add userId and conversationId columns
+   * Close the database connection
    */
-  async migrateAgentHistorySchema() {
-    const historyTableName = `${this.options.tablePrefix}_agent_history`;
+  async close() {
+    this.vectorCache.clear();
+    this.logger.debug("Vector adapter closed");
     try {
-      this.debug("Starting agent history schema migration...");
-      const flagCheck = await this.checkMigrationFlag("agent_history_schema_migration");
-      if (flagCheck.alreadyCompleted) {
-        return { success: true };
-      }
-      const tableInfo = await this.client.execute(`PRAGMA table_info(${historyTableName})`);
-      if (tableInfo.rows.length === 0) {
-        this.debug("Agent history table doesn't exist, migration not needed");
-        return { success: true };
-      }
-      const hasUserIdColumn = tableInfo.rows.some((row) => row.name === "userId");
-      const hasConversationIdColumn = tableInfo.rows.some((row) => row.name === "conversationId");
-      if (hasUserIdColumn && hasConversationIdColumn) {
-        this.debug("Both userId and conversationId columns already exist, skipping migration");
-        await this.setMigrationFlag("agent_history_schema_migration", 0);
-        return { success: true };
-      }
-      if (!hasUserIdColumn) {
-        await this.client.execute(`ALTER TABLE ${historyTableName} ADD COLUMN userId TEXT`);
-        this.debug("Added userId column to agent history table");
-      }
-      if (!hasConversationIdColumn) {
-        await this.client.execute(`ALTER TABLE ${historyTableName} ADD COLUMN conversationId TEXT`);
-        this.debug("Added conversationId column to agent history table");
-      }
-      if (!hasUserIdColumn) {
-        await this.client.execute(`
-          CREATE INDEX IF NOT EXISTS idx_${historyTableName}_userId 
-          ON ${historyTableName}(userId)
-        `);
-      }
-      if (!hasConversationIdColumn) {
-        await this.client.execute(`
-          CREATE INDEX IF NOT EXISTS idx_${historyTableName}_conversationId 
-          ON ${historyTableName}(conversationId)
-        `);
-      }
-      await this.setMigrationFlag("agent_history_schema_migration", 0);
-      this.debug("Agent history schema migration completed successfully");
-      return { success: true };
-    } catch (error) {
-      this.debug("Error during agent history schema migration:", error);
-      return {
-        success: false,
-        error
-      };
+      this.client?.close?.();
+    } catch {
     }
   }
-  // ===== WorkflowMemory Interface Implementation =====
-  // Delegate all workflow operations to the workflow extension
-  async storeWorkflowHistory(entry) {
-    await this.initialized;
-    return this.workflowExtension.storeWorkflowHistory(entry);
-  }
-  async getWorkflowHistory(id) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowHistory(id);
-  }
-  async getWorkflowHistoryByWorkflowId(workflowId) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowHistoryByWorkflowId(workflowId);
-  }
-  async updateWorkflowHistory(id, updates) {
-    await this.initialized;
-    return this.workflowExtension.updateWorkflowHistory(id, updates);
-  }
-  async deleteWorkflowHistory(id) {
-    await this.initialized;
-    return this.workflowExtension.deleteWorkflowHistory(id);
-  }
-  async storeWorkflowStep(step) {
-    await this.initialized;
-    return this.workflowExtension.storeWorkflowStep(step);
-  }
-  async getWorkflowStep(id) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowStep(id);
-  }
-  async getWorkflowSteps(workflowHistoryId) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowSteps(workflowHistoryId);
-  }
-  async updateWorkflowStep(id, updates) {
-    await this.initialized;
-    return this.workflowExtension.updateWorkflowStep(id, updates);
-  }
-  async deleteWorkflowStep(id) {
-    await this.initialized;
-    return this.workflowExtension.deleteWorkflowStep(id);
-  }
-  async storeWorkflowTimelineEvent(event) {
-    await this.initialized;
-    return this.workflowExtension.storeWorkflowTimelineEvent(event);
-  }
-  async getWorkflowTimelineEvent(id) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowTimelineEvent(id);
-  }
-  async getWorkflowTimelineEvents(workflowHistoryId) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowTimelineEvents(workflowHistoryId);
-  }
-  async deleteWorkflowTimelineEvent(id) {
-    await this.initialized;
-    return this.workflowExtension.deleteWorkflowTimelineEvent(id);
-  }
-  async getAllWorkflowIds() {
-    await this.initialized;
-    return this.workflowExtension.getAllWorkflowIds();
-  }
-  async getWorkflowStats(workflowId) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowStats(workflowId);
-  }
-  async getWorkflowHistoryWithStepsAndEvents(id) {
-    await this.initialized;
-    return this.workflowExtension.getWorkflowHistoryWithStepsAndEvents(id);
-  }
-  async deleteWorkflowHistoryWithRelated(id) {
-    await this.initialized;
-    return this.workflowExtension.deleteWorkflowHistoryWithRelated(id);
-  }
-  async cleanupOldWorkflowHistories(workflowId, maxEntries) {
-    await this.initialized;
-    return this.workflowExtension.cleanupOldWorkflowHistories(workflowId, maxEntries);
-  }
   /**
-   * Get the workflow extension for advanced workflow operations
+   * Get statistics about the vector table and cache
    */
-  getWorkflowExtension() {
-    return this.workflowExtension;
+  async getStats() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    const [countResult, sizeResult] = await Promise.all([
+      this.executeWithRetry(
+        async () => await this.client.execute(
+          `SELECT COUNT(*) as count, MAX(dimensions) as dims FROM ${tableName}`
+        ),
+        "getStats count"
+      ),
+      // Approximate table size by summing blob/text lengths
+      this.executeWithRetry(
+        async () => await this.client.execute({
+          sql: `SELECT 
+              COALESCE(SUM(LENGTH(id)),0) + 
+              COALESCE(SUM(LENGTH(vector)),0) + 
+              COALESCE(SUM(LENGTH(metadata)),0) +
+              COALESCE(SUM(LENGTH(content)),0) AS size
+            FROM ${tableName}`
+        }),
+        "getStats size"
+      )
+    ]);
+    const row1 = countResult.rows[0];
+    const row2 = sizeResult.rows[0];
+    const countRaw = row1?.count;
+    const dimsRaw = row1?.dims;
+    const sizeRaw = row2?.size;
+    const normalize = /* @__PURE__ */ __name((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number.parseInt(v, 10) || 0 : v ?? 0, "normalize");
+    return {
+      count: normalize(countRaw),
+      dimensions: dimsRaw != null ? normalize(dimsRaw) : this.dimensions,
+      cacheSize: this.vectorCache.size,
+      tableSizeBytes: normalize(sizeRaw)
+    };
   }
 };
 export {
-  LibSQLStorage
+  LibSQLMemoryAdapter,
+  LibSQLObservabilityAdapter,
+  LibSQLVectorAdapter
 };
 //# sourceMappingURL=index.mjs.map