@voltagent/libsql 0.1.0

package/dist/index.js

@@ -0,0 +1,3021 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LibSQLStorage: () => LibSQLStorage
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_client = require("@libsql/client");
+var import_core = require("@voltagent/core");
+var import_utils2 = require("@voltagent/internal/utils");
+var import_logger2 = require("@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);
+    }
+    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]
+    });
+    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 (
+        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(`
+      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;
+  }
+}
+__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
+var import_utils = require("@voltagent/internal/utils");
+var import_logger = require("@voltagent/logger");
+var LibSQLWorkflowExtension = class {
+  constructor(client, _tablePrefix = "voltagent_memory", logger) {
+    this.client = client;
+    this._tablePrefix = _tablePrefix;
+    this.logger = logger || (0, import_logger.createPinoLogger)({ name: "libsql-workflow" });
+  }
+  static {
+    __name(this, "LibSQLWorkflowExtension");
+  }
+  logger;
+  /**
+   * Store a workflow history entry
+   */
+  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,
+        (0, import_utils.safeStringify)(entry.input),
+        entry.output ? (0, import_utils.safeStringify)(entry.output) : null,
+        entry.userId || null,
+        entry.conversationId || null,
+        entry.metadata ? (0, import_utils.safeStringify)(entry.metadata) : null,
+        entry.createdAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString(),
+        entry.updatedAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+  }
+  /**
+   * Get a workflow history entry by ID
+   */
+  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]);
+  }
+  /**
+   * Get all workflow history entries for a specific workflow
+   */
+  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));
+  }
+  /**
+   * Update a workflow history entry
+   */
+  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);
+    }
+    if (updates.endTime !== void 0) {
+      setClauses.push("end_time = ?");
+      args.push(updates.endTime.toISOString());
+    }
+    if (updates.output !== void 0) {
+      setClauses.push("output = ?");
+      args.push((0, import_utils.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 = (0, import_utils.safeStringify)(updates.metadata);
+      args.push(metadataJson);
+      this.logger.trace(`Setting metadata for ${id}:`, { metadata: metadataJson });
+    }
+    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;
+    }
+  }
+  /**
+   * Delete a workflow history entry
+   */
+  async deleteWorkflowHistory(id) {
+    await this.client.execute({
+      sql: `DELETE FROM ${this._tablePrefix}_workflow_history WHERE id = ?`,
+      args: [id]
+    });
+  }
+  /**
+   * Store a workflow step entry
+   */
+  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 ? (0, import_utils.safeStringify)(step.input) : null,
+        step.output ? (0, import_utils.safeStringify)(step.output) : null,
+        step.error ? (0, import_utils.safeStringify)(step.error) : null,
+        step.agentExecutionId || null,
+        step.parallelIndex || null,
+        step.parallelParentStepId || null,
+        step.metadata ? (0, import_utils.safeStringify)(step.metadata) : null,
+        step.createdAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString(),
+        step.updatedAt?.toISOString() || (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+  }
+  /**
+   * Get a workflow step by ID
+   */
+  async getWorkflowStep(id) {
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${this._tablePrefix}_workflow_steps WHERE id = ?`,
+      args: [id]
+    });
+    if (result.rows.length === 0) return null;
+    return this.parseWorkflowStepRow(result.rows[0]);
+  }
+  /**
+   * Get all workflow steps for a specific workflow history
+   */
+  async getWorkflowSteps(workflowHistoryId) {
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${this._tablePrefix}_workflow_steps WHERE workflow_history_id = ? ORDER BY step_index ASC`,
+      args: [workflowHistoryId]
+    });
+    return result.rows.map((row) => this.parseWorkflowStepRow(row));
+  }
+  /**
+   * Update a workflow step
+   */
+  async updateWorkflowStep(id, updates) {
+    const setClauses = [];
+    const args = [];
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      args.push(updates.status);
+    }
+    if (updates.endTime !== void 0) {
+      setClauses.push("end_time = ?");
+      args.push(updates.endTime.toISOString());
+    }
+    if (updates.output !== void 0) {
+      setClauses.push("output = ?");
+      args.push((0, import_utils.safeStringify)(updates.output));
+    }
+    if (updates.error !== void 0) {
+      setClauses.push("error_message = ?");
+      args.push((0, import_utils.safeStringify)(updates.error));
+    }
+    if (updates.agentExecutionId !== void 0) {
+      setClauses.push("agent_execution_id = ?");
+      args.push(updates.agentExecutionId);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      args.push((0, import_utils.safeStringify)(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 = ?`,
+      args
+    });
+  }
+  /**
+   * 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
+   */
+  async storeWorkflowTimelineEvent(event) {
+    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 ? (0, import_utils.safeStringify)(event.input) : null,
+        event.output ? (0, import_utils.safeStringify)(event.output) : null,
+        event.statusMessage ? (0, import_utils.safeStringify)(event.statusMessage) : null,
+        event.metadata ? (0, import_utils.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 = ?`,
+      args: [id]
+    });
+    if (result.rows.length === 0) return null;
+    return this.parseWorkflowTimelineEventRow(result.rows[0]);
+  }
+  /**
+   * Get all workflow timeline events for a specific workflow history
+   */
+  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));
+  }
+  /**
+   * Delete a workflow timeline event
+   */
+  async deleteWorkflowTimelineEvent(id) {
+    await this.client.execute({
+      sql: `DELETE FROM ${this._tablePrefix}_workflow_timeline_events WHERE id = ?`,
+      args: [id]
+    });
+  }
+  /**
+   * Get all workflow IDs
+   */
+  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);
+  }
+  /**
+   * Get workflow statistics
+   */
+  async getWorkflowStats(workflowId) {
+    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]
+    });
+    if (result.rows.length === 0) {
+      return {
+        totalExecutions: 0,
+        successfulExecutions: 0,
+        failedExecutions: 0,
+        averageExecutionTime: 0,
+        lastExecutionTime: void 0
+      };
+    }
+    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
+    };
+  }
+  /**
+   * Get workflow history with all related data (steps and events)
+   */
+  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;
+  }
+  /**
+   * Delete workflow history and all related data
+   */
+  async deleteWorkflowHistoryWithRelated(id) {
+    await this.deleteWorkflowHistory(id);
+  }
+  /**
+   * Clean up old workflow histories
+   */
+  async cleanupOldWorkflowHistories(workflowId, maxEntries) {
+    const countResult = await this.client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${this._tablePrefix}_workflow_history WHERE workflow_id = ?`,
+      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 {
+      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,
+      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
+   */
+  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)
+    };
+  }
+};
+
+// 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 {
+  static {
+    __name(this, "LibSQLStorage");
+  }
+  client;
+  options;
+  initialized;
+  workflowExtension;
+  logger;
+  retryAttempts;
+  baseDelayMs;
+  /**
+   * Create a new LibSQL storage
+   * @param options Configuration options
+   */
+  constructor(options) {
+    this.logger = options.logger || (0, import_logger2.createPinoLogger)({ 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);
+      const dir = (0, import_node_path.dirname)(filePath);
+      if (dir && dir !== "." && !(0, import_node_fs.existsSync)(dir)) {
+        try {
+          (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+          this.debug("Created directory for database", { dir });
+        } catch (error) {
+          this.logger.warn("Failed to create directory for database", { dir, error });
+        }
+      }
+    }
+    this.client = (0, import_client.createClient)({
+      url: this.options.url,
+      authToken: this.options.authToken
+    });
+    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) {
+      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
+   */
+  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
+        )
+      `);
+    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)
+        )
+      `);
+    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
+        )
+      `);
+    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
+        )
+      `);
+    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_${messagesTableName}_lookup
+        ON ${messagesTableName}(conversation_id, created_at)
+      `);
+    await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${conversationsTableName}_resource
+        ON ${conversationsTableName}(resource_id)
+      `);
+    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.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_${historyStepsTableName}_agent_id 
+        ON ${historyStepsTableName}(agent_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_${timelineEventsTableName}_agent_id 
+        ON ${timelineEventsTableName}(agent_id)
+      `);
+    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_${timelineEventsTableName}_event_name 
+        ON ${timelineEventsTableName}(event_name)
+      `);
+    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_${timelineEventsTableName}_status 
+        ON ${timelineEventsTableName}(status)
+      `);
+    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);
+      }
+    } catch (error) {
+      this.debug("Error migrating agent history schema:", error);
+    }
+    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");
+        }
+      }
+    } catch (error) {
+      this.debug("Error initializing database:", 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
+   */
+  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`;
+    try {
+      let sql = `
+        SELECT m.message_id, m.role, m.content, m.type, m.created_at, m.conversation_id
+        FROM ${messagesTableName} m
+      `;
+      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 (conversationId !== "default") {
+        conditions.push("m.conversation_id = ?");
+        args.push(conversationId);
+      }
+      if (before) {
+        conditions.push("m.created_at < ?");
+        args.push(new Date(before).toISOString());
+      }
+      if (after) {
+        conditions.push("m.created_at > ?");
+        args.push(new Date(after).toISOString());
+      }
+      if (role) {
+        conditions.push("m.role = ?");
+        args.push(role);
+      }
+      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 (limit && limit > 0) {
+        sql += " ORDER BY m.created_at DESC LIMIT ?";
+        args.push(limit);
+      } else {
+        sql += " ORDER BY m.created_at ASC";
+      }
+      const result = await this.client.execute({
+        sql,
+        args
+      });
+      const messages = result.rows.map((row) => {
+        let content = row.content;
+        const parsedContent = (0, import_core.safeJsonParse)(content);
+        if (parsedContent !== null) {
+          content = parsedContent;
+        }
+        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;
+    } catch (error) {
+      this.debug("Error getting messages:", error);
+      throw new Error("Failed to get messages from LibSQL database");
+    }
+  }
+  /**
+   * 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")
+   */
+  async addMessage(message, conversationId = "default") {
+    await this.initialized;
+    await debugDelay();
+    const tableName = `${this.options.tablePrefix}_messages`;
+    const contentString = (0, import_utils2.safeStringify)(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
+        ]
+      });
+      this.debug("Message added successfully", { conversationId, messageId: message.id });
+      try {
+        await this.pruneOldMessages(conversationId);
+      } catch (pruneError) {
+        this.debug("Error pruning old messages:", pruneError);
+      }
+    }, `addMessage[${message.id}]`);
+  }
+  /**
+   * Prune old messages to respect storage limit
+   * @param conversationId Conversation ID to prune messages for
+   */
+  async pruneOldMessages(conversationId) {
+    const limit = this.options.storageLimit || 100;
+    const tableName = `${this.options.tablePrefix}_messages`;
+    try {
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${tableName} WHERE conversation_id = ?`,
+        args: [conversationId]
+      });
+      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}`);
+      }
+    } catch (error) {
+      this.debug("Error pruning old messages:", error);
+      throw error;
+    }
+  }
+  /**
+   * Clear messages from memory
+   */
+  async clearMessages(options) {
+    await this.initialized;
+    await debugDelay();
+    const { userId, conversationId } = options;
+    const messagesTableName = `${this.options.tablePrefix}_messages`;
+    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
+    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}`);
+      } 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}`);
+      }
+    } catch (error) {
+      this.debug("Error clearing messages:", error);
+      throw new Error("Failed to clear messages from LibSQL database");
+    }
+  }
+  /**
+   * Close the database connection
+   */
+  async close() {
+    try {
+      await this.initialized;
+    } catch {
+    }
+    this.client.close();
+  }
+  /**
+   * Add or update a history entry
+   * @param key Entry ID
+   * @param value Entry data
+   * @param agentId Agent ID for filtering
+   */
+  async addHistoryEntry(key, value, agentId) {
+    await this.initialized;
+    try {
+      const tableName = `${this.options.tablePrefix}_agent_history`;
+      const inputJSON = value.input ? (0, import_utils2.safeStringify)(value.input) : null;
+      const outputJSON = value.output ? (0, import_utils2.safeStringify)(value.output) : null;
+      const usageJSON = value.usage ? (0, import_utils2.safeStringify)(value.usage) : null;
+      const metadataJSON = value.metadata ? (0, import_utils2.safeStringify)(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}`);
+    } catch (error) {
+      this.debug("Error setting agent_history entry:", error);
+      throw new Error("Failed to set value in agent_history");
+    }
+  }
+  /**
+   * Update an existing history entry
+   * @param key Entry ID
+   * @param value Updated entry data
+   * @param agentId Agent ID for filtering
+   */
+  async updateHistoryEntry(key, value, agentId) {
+    return this.addHistoryEntry(key, value, agentId);
+  }
+  /**
+   * Add a history step
+   * @param key Step ID
+   * @param value Step data
+   * @param historyId Related history entry ID
+   * @param agentId Agent ID for filtering
+   */
+  async addHistoryStep(key, value, historyId, agentId) {
+    await this.initialized;
+    try {
+      const tableName = `${this.options.tablePrefix}_agent_history_steps`;
+      const serializedValue = (0, import_utils2.safeStringify)(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}`);
+    } catch (error) {
+      this.debug(`Error setting agent_history_steps:${key}`, error);
+      throw new Error("Failed to set value in agent_history_steps");
+    }
+  }
+  /**
+   * 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
+   */
+  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;
+    try {
+      const tableName = `${this.options.tablePrefix}_agent_history_timeline_events`;
+      const inputJSON = value.input ? (0, import_utils2.safeStringify)(value.input) : null;
+      const outputJSON = value.output ? (0, import_utils2.safeStringify)(value.output) : null;
+      const statusMessageJSON = value.statusMessage ? (0, import_utils2.safeStringify)(value.statusMessage) : null;
+      const metadataJSON = value.metadata ? (0, import_utils2.safeStringify)(value.metadata) : null;
+      const tagsJSON = value.tags ? (0, import_utils2.safeStringify)(value.tags) : 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        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
+        ]
+      });
+      this.debug(`Added timeline event ${key} for history ${historyId}`);
+    } catch (error) {
+      this.debug("Error adding timeline event:", error);
+      throw new Error("Failed to add timeline event");
+    }
+  }
+  /**
+   * Get a history entry by ID
+   * @param key Entry ID
+   * @returns The history entry or undefined if not found
+   */
+  async getHistoryEntry(key) {
+    await this.initialized;
+    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 ? (0, import_core.safeJsonParse)(row.input) : null,
+        output: row.output ? (0, import_core.safeJsonParse)(row.output) : null,
+        usage: row.usage ? (0, import_core.safeJsonParse)(row.usage) : null,
+        metadata: row.metadata ? (0, import_core.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 = (0, import_core.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 ? (0, import_core.safeJsonParse)(row2.input) : void 0;
+        const output = row2.output ? (0, import_core.safeJsonParse)(row2.output) : void 0;
+        const error = row2.error ? (0, import_core.safeJsonParse)(row2.error) : void 0;
+        const statusMessage = row2.status_message ? (0, import_core.safeJsonParse)(row2.status_message) : void 0;
+        const metadata = row2.metadata ? (0, import_core.safeJsonParse)(row2.metadata) : void 0;
+        const tags = row2.tags ? (0, import_core.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
+        };
+      });
+      entry.steps = steps;
+      entry.events = events;
+      return entry;
+    } catch (error) {
+      this.debug(`Error getting history entry with ID ${key}`, error);
+      return void 0;
+    }
+  }
+  /**
+   * Get a history step by ID
+   * @param key Step ID
+   * @returns The history step or undefined if not found
+   */
+  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 = (0, import_core.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 = (0, import_utils2.safeStringify)(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 ? (0, import_core.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: (0, import_core.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`;
+    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
+      });
+      return result.rows.map((row) => ({
+        id: row.id,
+        resourceId: row.resource_id,
+        userId: row.user_id,
+        title: row.title,
+        metadata: (0, import_core.safeJsonParse)(row.metadata),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      }));
+    } catch (error) {
+      this.debug("Error getting conversations by user ID:", error);
+      throw new Error("Failed to get conversations by user ID from LibSQL database");
+    }
+  }
+  /**
+   * 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}
+   */
+  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`;
+    try {
+      let sql = `SELECT * FROM ${tableName}`;
+      const args = [];
+      const conditions = [];
+      if (userId) {
+        conditions.push("user_id = ?");
+        args.push(userId);
+      }
+      if (resourceId) {
+        conditions.push("resource_id = ?");
+        args.push(resourceId);
+      }
+      if (conditions.length > 0) {
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      }
+      sql += ` ORDER BY ${orderBy} ${orderDirection}`;
+      if (limit > 0) {
+        sql += " LIMIT ? OFFSET ?";
+        args.push(limit, offset);
+      }
+      const result = await this.client.execute({
+        sql,
+        args
+      });
+      return result.rows.map((row) => ({
+        id: row.id,
+        resourceId: row.resource_id,
+        userId: row.user_id,
+        title: row.title,
+        metadata: (0, import_core.safeJsonParse)(row.metadata),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      }));
+    } catch (error) {
+      this.debug("Error querying conversations:", error);
+      throw new Error("Failed to query conversations from LibSQL database");
+    }
+  }
+  /**
+   * 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}
+   */
+  async getConversationMessages(conversationId, options = {}) {
+    await this.initialized;
+    await debugDelay();
+    const { limit = 100, offset = 0 } = options;
+    const tableName = `${this.options.tablePrefix}_messages`;
+    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 result = await this.client.execute({
+        sql,
+        args
+      });
+      return result.rows.map((row) => {
+        let content = row.content;
+        const parsedContent = (0, import_core.safeJsonParse)(content);
+        if (parsedContent !== null) {
+          content = parsedContent;
+        }
+        return {
+          id: row.message_id,
+          role: row.role,
+          content,
+          type: row.type,
+          createdAt: row.created_at
+        };
+      });
+    } catch (error) {
+      this.debug("Error getting conversation messages:", error);
+      throw new Error("Failed to get conversation messages from LibSQL database");
+    }
+  }
+  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);
+      }
+      if (updates.title !== void 0) {
+        updatesList.push("title = ?");
+        args.push(updates.title);
+      }
+      if (updates.metadata !== void 0) {
+        updatesList.push("metadata = ?");
+        args.push((0, import_utils2.safeStringify)(updates.metadata));
+      }
+      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 updated;
+    } catch (error) {
+      this.debug("Error updating conversation:", error);
+      throw new Error("Failed to update conversation in LibSQL database");
+    }
+  }
+  async deleteConversation(id) {
+    await this.initialized;
+    await debugDelay();
+    const conversationsTableName = `${this.options.tablePrefix}_conversations`;
+    const messagesTableName = `${this.options.tablePrefix}_messages`;
+    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]
+      });
+    } catch (error) {
+      this.debug("Error deleting conversation:", error);
+      throw new Error("Failed to delete conversation from LibSQL database");
+    }
+  }
+  /**
+   * 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
+   */
+  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 ? (0, import_core.safeJsonParse)(row.input) : null,
+        output: row.output ? (0, import_core.safeJsonParse)(row.output) : null,
+        usage: row.usage ? (0, import_core.safeJsonParse)(row.usage) : null,
+        metadata: row.metadata ? (0, import_core.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 = (0, import_core.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 ? (0, import_core.safeJsonParse)(row.input) : void 0;
+            const output = row.output ? (0, import_core.safeJsonParse)(row.output) : void 0;
+            const error = row.error ? (0, import_core.safeJsonParse)(row.error) : void 0;
+            const statusMessage = row.status_message ? (0, import_core.safeJsonParse)(row.status_message) : void 0;
+            const metadata = row.metadata ? (0, import_core.safeJsonParse)(row.metadata) : void 0;
+            const tags = row.tags ? (0, import_core.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
+      };
+    }
+  }
+  /**
+   * 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
+   * );
+   */
+  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};`);
+        }
+        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}`
+      });
+      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 = (0, import_core.safeJsonParse)(valueStr);
+          const id = valueObj.id || key;
+          if (migratedIds.has(id)) {
+            continue;
+          }
+          migratedIds.add(id);
+          migratedCount++;
+          const inputJSON = valueObj.input ? (0, import_utils2.safeStringify)(valueObj.input) : null;
+          const outputJSON = valueObj.output ? (0, import_utils2.safeStringify)(valueObj.output) : null;
+          const usageJSON = valueObj.usage ? (0, import_utils2.safeStringify)(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 = (0, import_utils2.safeStringify)({ input: event.input });
+                } else if (event.data?.input) {
+                  inputData = (0, import_utils2.safeStringify)({ input: event.data.input });
+                } else if (input) {
+                  inputData = (0, import_utils2.safeStringify)({ input });
+                }
+                input = "";
+                let metadata = null;
+                if (event.metadata) {
+                  metadata = (0, import_utils2.safeStringify)(event.metadata);
+                } else if (event.data) {
+                  metadata = (0, import_utils2.safeStringify)({
+                    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 ? (0, import_utils2.safeStringify)(event.data.output) : null,
+                      eventName === "agent:error" ? (0, import_utils2.safeStringify)(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
+                        (0, import_utils2.safeStringify)({
+                          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 ? (0, import_utils2.safeStringify)(event.data.output) : null,
+                        event.error ? (0, import_utils2.safeStringify)(event.error) : null,
+                        (0, import_utils2.safeStringify)({
+                          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
+                        (0, import_utils2.safeStringify)({
+                          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 ? (0, import_utils2.safeStringify)(event.data.output) : null,
+                        event.error ? (0, import_utils2.safeStringify)(event.error) : null,
+                        (0, import_utils2.safeStringify)({
+                          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 ? (0, import_utils2.safeStringify)(event.output) : null,
+                        event.error ? (0, import_utils2.safeStringify)(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
+                        (0, import_utils2.safeStringify)({
+                          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 ? (0, import_utils2.safeStringify)(event.data.output) : null,
+                        event.error ? (0, import_utils2.safeStringify)(event.error) : null,
+                        (0, import_utils2.safeStringify)({
+                          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 ? (0, import_utils2.safeStringify)(event.output) : null,
+                      event.error ? (0, import_utils2.safeStringify)(event.error) : null,
+                      (0, import_utils2.safeStringify)({
+                        id: eventType === "retriever" ? "retriever" : event.type,
+                        agentId: event.affectedNodeId?.split("_").pop()
+                      })
+                    ]
+                  });
+                }
+              } catch (error) {
+                this.debug("Error processing event:", error);
+              }
+            }
+          }
+        } catch (error) {
+          this.debug(`Error processing record with ID ${key}:`, error);
+        }
+      }
+      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
+      };
+    }
+  }
+  /**
+   * 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
+   */
+  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})`
+      );
+      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;
+      }
+      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
+                (0, import_utils2.safeStringify)({}),
+                // 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
+          ]
+        });
+      }
+      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);
+      }
+      return {
+        success: false,
+        error,
+        backupCreated: createBackup
+      };
+    }
+  }
+  /**
+   * Get conversations for a user with a fluent query builder interface
+   * @param userId User ID to filter by
+   * @returns Query builder object
+   */
+  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")
+    };
+  }
+  /**
+   * 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
+   */
+  async getUserConversation(conversationId, userId) {
+    const conversation = await this.getConversation(conversationId);
+    if (!conversation || conversation.userId !== userId) {
+      return null;
+    }
+    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
+   */
+  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
+    };
+  }
+  /**
+   * 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
+   */
+  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`);
+        return {
+          alreadyCompleted: true,
+          migrationCount: migrationFlag.migrated_count,
+          completedAt: migrationFlag.completed_at
+        };
+      }
+      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);
+    }
+  }
+  /**
+   * Migrate agent history schema to add userId and conversationId columns
+   */
+  async migrateAgentHistorySchema() {
+    const historyTableName = `${this.options.tablePrefix}_agent_history`;
+    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
+      };
+    }
+  }
+  // ===== 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
+   */
+  getWorkflowExtension() {
+    return this.workflowExtension;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LibSQLStorage
+});
+//# sourceMappingURL=index.js.map